#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 */
int /*<<< orphan*/ bpsconv(double *, int, double *, double *, int, int,
                           double *, double *);
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(double *);
void MIDWT(double *x, int m, int n, double *h, int lh, int L, double *y) {
  double *g0, *g1, *ydummyl, *ydummyh, *xdummy;
  long i, j;
  int actual_L, actual_m, actual_n, r_o_a, c_o_a, ir, ic, lhm1, lhhm1, sample_f;
  xdummy = (double *)calloc((m > n ? m : n), sizeof(double));
  ydummyl = (double *)calloc((m > n ? m : n) + lh / 2 - 1, sizeof(double));
  ydummyh = (double *)calloc((m > n ? m : n) + lh / 2 - 1, sizeof(double));
  g0 = (double *)calloc(lh, sizeof(double));
  g1 = (double *)calloc(lh, sizeof(double));
  if (n == 1) {
    n = m;
    m = 1;
  }
  for (i = 0; i < lh; i++) {
    g0[i] = h[i];
    g1[i] = h[lh - i - 1];
  }
  for (i = 1; i <= lh; i += 2)
    g1[i] = -g1[i];
  lhm1 = lh - 1;
  lhhm1 = lh / 2 - 1;
  sample_f = 1;
  for (i = 1; i < L; i++)
    sample_f = sample_f * 2;
  if (m > 1)
    actual_m = m / sample_f;
  else
    actual_m = 1;
  actual_n = n / sample_f;
  for (i = 0; i < (m * n); i++)
    x[i] = y[i];
  for (actual_L = L; actual_L >= 1; actual_L--) {
    r_o_a = actual_m / 2;
    c_o_a = actual_n / 2;
    if (m > 1) {
      for (ic = 0; ic < actual_n; ic++) {
        ir = r_o_a;
        for (i = 0; i < r_o_a; i++) {
          ydummyl[i + lhhm1] = (*(x + (m * (ic) + i)));
          ydummyh[i + lhhm1] = (*(x + (m * (ic) + ir++)));
        }
        bpsconv(xdummy, r_o_a, g0, g1, lhm1, lhhm1, ydummyl, ydummyh);
        for (i = 0; i < actual_m; i++)
          (*(x + (m * (ic) + i))) = xdummy[i];
      }
    }
    for (ir = 0; ir < actual_m; ir++) {
      ic = c_o_a;
      for (i = 0; i < c_o_a; i++) {
        ydummyl[i + lhhm1] = (*(x + (m * (i) + ir)));
        ydummyh[i + lhhm1] = (*(x + (m * (ic++) + ir)));
      }
      bpsconv(xdummy, c_o_a, g0, g1, lhm1, lhhm1, ydummyl, ydummyh);
      for (i = 0; i < actual_n; i++)
        (*(x + (m * (i) + ir))) = xdummy[i];
    }
    if (m == 1)
      actual_m = 1;
    else
      actual_m = actual_m * 2;
    actual_n = actual_n * 2;
  }
  free(xdummy);
  free(ydummyl);
  free(ydummyh);
  free(g0);
  free(g1);
}


x86 assembly (clang, -O0):
<MIDWT>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%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    116f <MIDWT+0x3f>
mov    -0xc(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    1178 <MIDWT+0x48>
mov    -0x10(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    11a6 <MIDWT+0x76>
mov    -0xc(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    11af <MIDWT+0x7f>
mov    -0x10(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%edi
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    %eax,%edi
sub    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    11ed <MIDWT+0xbd>
mov    -0xc(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    11f6 <MIDWT+0xc6>
mov    -0x10(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%edi
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    %eax,%edi
sub    $0x1,%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    1253 <MIDWT+0x123>
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    12b9 <MIDWT+0x189>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
sub    -0x50(%rbp),%rcx
sub    $0x1,%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    125b <MIDWT+0x12b>
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jg     1314 <MIDWT+0x1e4>
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    12c1 <MIDWT+0x191>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
movl   $0x1,-0x80(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
cmp    %rcx,%rax
jge    1368 <MIDWT+0x238>
mov    -0x80(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    133d <MIDWT+0x20d>
cmpl   $0x1,-0xc(%rbp)
jle    1381 <MIDWT+0x251>
mov    -0xc(%rbp),%eax
cltd
idivl  -0x80(%rbp)
mov    %eax,-0x60(%rbp)
jmp    1388 <MIDWT+0x258>
movl   $0x1,-0x60(%rbp)
mov    -0x10(%rbp),%eax
cltd
idivl  -0x80(%rbp)
mov    %eax,-0x64(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    13dc <MIDWT+0x2ac>
mov    0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    139a <MIDWT+0x26a>
mov    -0x20(%rbp),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x1,-0x5c(%rbp)
jl     16b1 <MIDWT+0x581>
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,-0x6c(%rbp)
cmpl   $0x1,-0xc(%rbp)
jle    1547 <MIDWT+0x417>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    1542 <MIDWT+0x412>
mov    -0x68(%rbp),%eax
mov    %eax,-0x70(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
cmp    %rcx,%rax
jge    14b4 <MIDWT+0x384>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
add    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%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  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1433 <MIDWT+0x303>
mov    -0x48(%rbp),%rdi
mov    -0x68(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x78(%rbp),%r8d
mov    -0x7c(%rbp),%r9d
mov    -0x38(%rbp),%r10
mov    -0x40(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1050 <bpsconv@plt>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x60(%rbp),%rcx
cmp    %rcx,%rax
jge    152f <MIDWT+0x3ff>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
add    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    14e9 <MIDWT+0x3b9>
jmp    1534 <MIDWT+0x404>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1419 <MIDWT+0x2e9>
jmp    1547 <MIDWT+0x417>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    167b <MIDWT+0x54b>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cmp    %rcx,%rax
jge    15eb <MIDWT+0x4bb>
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    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%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  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1568 <MIDWT+0x438>
mov    -0x48(%rbp),%rdi
mov    -0x6c(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x78(%rbp),%r8d
mov    -0x7c(%rbp),%r9d
mov    -0x38(%rbp),%r10
mov    -0x40(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1050 <bpsconv@plt>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
cmp    %rcx,%rax
jge    1668 <MIDWT+0x538>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   -0x50(%rbp),%rcx
movslq -0x70(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1620 <MIDWT+0x4f0>
jmp    166d <MIDWT+0x53d>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    154e <MIDWT+0x41e>
cmpl   $0x1,-0xc(%rbp)
jne    1691 <MIDWT+0x561>
movl   $0x1,-0x60(%rbp)
jmp    169a <MIDWT+0x56a>
mov    -0x60(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    13e2 <MIDWT+0x2b2>
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    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MIDWT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,0x98(%rsp)
mov    %r8d,%r13d
mov    %rcx,%rbx
mov    %esi,%ebp
mov    %rdi,0x38(%rsp)
mov    0x1c0(%rsp),%r12
mov    %edx,0x48(%rsp)
cmp    %edx,%esi
mov    %edx,%r14d
cmovg  %esi,%r14d
mov    %r14d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r15
mov    %r13d,%eax
shr    $0x1f,%eax
add    %r13d,%eax
sar    %eax
mov    %rax,0x90(%rsp)
add    %eax,%r14d
add    $0xffffffff,%r14d
mov    %r14d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,0x30(%rsp)
mov    %r14d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    %r13d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r14
mov    %r13d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    0x48(%rsp),%ecx
cmp    $0x1,%ecx
mov    %ecx,%r9d
cmove  %ebp,%r9d
cmove  %ecx,%ebp
mov    %r13d,0x14(%rsp)
test   %r13d,%r13d
mov    %r14,0x60(%rsp)
mov    %rax,0x58(%rsp)
jle    1415 <MIDWT+0x2e5>
mov    0x14(%rsp),%ecx
movslq %ecx,%r8
cmp    $0x4,%ecx
jae    129e <MIDWT+0x16e>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
test   $0x1,%r8b
je     123a <MIDWT+0x10a>
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
lea    (%rcx,%r8,1),%rsi
movsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
or     $0x1,%rdx
add    %r8,%rcx
je     13e5 <MIDWT+0x2b5>
mov    %r8,%rcx
sub    %rdx,%rcx
lea    (%rbx,%rcx,8),%rcx
add    $0xfffffffffffffff8,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
movsd  -0x8(%rcx),%xmm0
movsd  %xmm0,0x8(%rax,%rdx,8)
add    $0x2,%rdx
add    $0xfffffffffffffff0,%rcx
cmp    %rdx,%r8
jne    1260 <MIDWT+0x130>
jmp    13e5 <MIDWT+0x2b5>
lea    (%r14,%r8,8),%rdx
lea    (%rax,%r8,8),%rdi
lea    (%rbx,%r8,8),%rsi
cmp    %rdi,%r14
setb   %r11b
cmp    %rdx,%rax
mov    %r14,%rcx
setb   %r14b
cmp    %rsi,%rcx
setb   %cl
cmp    %rbx,%rdx
seta   %r10b
cmp    %rsi,%rax
setb   %sil
cmp    %rbx,%rdi
seta   %al
xor    %edx,%edx
test   %r14b,%r11b
jne    157d <MIDWT+0x44d>
and    %r10b,%cl
jne    157d <MIDWT+0x44d>
and    %al,%sil
mov    0x60(%rsp),%r14
mov    0x58(%rsp),%rax
jne    1211 <MIDWT+0xe1>
mov    %r8,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     2405 <MIDWT+0x12d5>
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
lea    -0x8(%r8),%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rsi,8),%xmm0
movups 0x10(%rbx,%rsi,8),%xmm1
movups %xmm0,(%r14,%rsi,8)
movups %xmm1,0x10(%r14,%rsi,8)
movups 0x20(%rbx,%rcx,8),%xmm0
movups 0x30(%rbx,%rcx,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,(%rax,%rsi,8)
movups %xmm0,0x10(%rax,%rsi,8)
movups 0x20(%rbx,%rsi,8),%xmm0
movups 0x30(%rbx,%rsi,8),%xmm1
movups %xmm0,0x20(%r14,%rsi,8)
movups %xmm1,0x30(%r14,%rsi,8)
movups (%rbx,%rcx,8),%xmm0
movups 0x10(%rbx,%rcx,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,0x20(%rax,%rsi,8)
movups %xmm0,0x30(%rax,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1330 <MIDWT+0x200>
test   $0x1,%r10b
je     13dc <MIDWT+0x2ac>
movups (%rbx,%rsi,8),%xmm0
movups 0x10(%rbx,%rsi,8),%xmm1
movups %xmm0,(%r14,%rsi,8)
movups %xmm1,0x10(%r14,%rsi,8)
mov    %rsi,%rcx
not    %rcx
add    %r8,%rcx
movups -0x18(%rbx,%rcx,8),%xmm0
movups -0x8(%rbx,%rcx,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,(%rax,%rsi,8)
movups %xmm0,0x10(%rax,%rsi,8)
cmp    %r8,%rdx
jne    1211 <MIDWT+0xe1>
cmpl   $0x0,0x14(%rsp)
jle    1415 <MIDWT+0x2e5>
mov    $0x1,%ecx
movaps 0x1c08(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %r8,%rcx
jle    1400 <MIDWT+0x2d0>
mov    $0x1,%edi
mov    $0x1,%esi
mov    0x98(%rsp),%r10
cmp    $0x2,%r10d
mov    0x38(%rsp),%rbx
jl     1478 <MIDWT+0x348>
movslq %r10d,%rdx
lea    -0x1(%rdx),%rcx
add    $0xfffffffffffffffe,%rdx
mov    %ecx,%eax
and    $0x7,%eax
cmp    $0x7,%rdx
jae    144f <MIDWT+0x31f>
mov    $0x1,%esi
jmp    1469 <MIDWT+0x339>
and    $0xfffffffffffffff8,%rcx
mov    $0x1,%esi
nopl   0x0(%rax,%rax,1)
shl    $0x8,%esi
add    $0xfffffffffffffff8,%rcx
jne    1460 <MIDWT+0x330>
test   %rax,%rax
je     1478 <MIDWT+0x348>
xchg   %ax,%ax
add    %esi,%esi
add    $0xffffffffffffffff,%rax
jne    1470 <MIDWT+0x340>
cmp    $0x2,%ebp
jl     1484 <MIDWT+0x354>
mov    %ebp,%eax
cltd
idiv   %esi
mov    %eax,%edi
mov    %r9d,%eax
cltd
idiv   %esi
mov    %eax,0x4(%rsp)
imul   %ebp,%r9d
test   %r9d,%r9d
mov    %rbx,%rdx
jle    165a <MIDWT+0x52a>
movslq %r9d,%rax
cmp    $0x4,%r9d
jb     14c4 <MIDWT+0x394>
lea    (%r12,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1550 <MIDWT+0x420>
mov    %rbx,%rdx
lea    (%rbx,%rax,8),%rcx
cmp    %r12,%rcx
jbe    1550 <MIDWT+0x420>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     14f5 <MIDWT+0x3c5>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    14e0 <MIDWT+0x3b0>
cmp    $0x3,%rdx
mov    %rbx,%rdx
jb     165a <MIDWT+0x52a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
movsd  0x10(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rcx,8)
movsd  0x18(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1510 <MIDWT+0x3e0>
jmp    165a <MIDWT+0x52a>
mov    %edi,%r9d
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdx
jae    158c <MIDWT+0x45c>
xor    %edi,%edi
jmp    1610 <MIDWT+0x4e0>
mov    0x60(%rsp),%r14
mov    0x58(%rsp),%rax
jmp    1211 <MIDWT+0xe1>
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
add    $0xfffffffffffffffe,%rdx
and    %rdx,%rsi
xor    %edi,%edi
mov    %rbx,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r12,%rdi,8),%xmm0
movups 0x10(%r12,%rdi,8),%xmm1
movups %xmm0,(%rdx,%rdi,8)
movups %xmm1,0x10(%rdx,%rdi,8)
movups 0x20(%r12,%rdi,8),%xmm0
movups 0x30(%r12,%rdi,8),%xmm1
movups %xmm0,0x20(%rdx,%rdi,8)
movups %xmm1,0x30(%rdx,%rdi,8)
movups 0x40(%r12,%rdi,8),%xmm0
movups 0x50(%r12,%rdi,8),%xmm1
movups %xmm0,0x40(%rdx,%rdi,8)
movups %xmm1,0x50(%rdx,%rdi,8)
movups 0x60(%r12,%rdi,8),%xmm0
movups 0x70(%r12,%rdi,8),%xmm1
movups %xmm0,0x60(%rdx,%rdi,8)
movups %xmm1,0x70(%rdx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    15b0 <MIDWT+0x480>
test   %r8,%r8
je     164b <MIDWT+0x51b>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%r12,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1630 <MIDWT+0x500>
cmp    %rax,%rcx
mov    %r9d,%edi
mov    %rbx,%rdx
jne    14c6 <MIDWT+0x396>
test   %r10d,%r10d
jle    23c4 <MIDWT+0x1294>
mov    %rdx,%r9
mov    0x90(%rsp),%rax
add    $0xffffffff,%eax
addl   $0xffffffff,0x14(%rsp)
mov    %rax,0x90(%rsp)
movslq %eax,%rcx
movslq %ebp,%rdx
mov    0x30(%rsp),%rax
lea    (%rax,%rcx,8),%r8
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%r13
lea    0x30(%r9),%rax
mov    %rax,0x140(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x80(%rsp)
mov    %rcx,0xf8(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x178(%rsp)
lea    0x70(%r9),%rax
mov    %rax,0x138(%rsp)
lea    0x10(%r9),%rax
mov    %rax,0x128(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x150(%rsp)
mov    %rdx,%rax
shl    $0x5,%rax
mov    %rax,0x130(%rsp)
mov    %rdx,%rax
shl    $0x4,%rax
mov    %rax,0x180(%rsp)
mov    %rdx,0x120(%rsp)
shl    $0x6,%rdx
mov    %rdx,0x170(%rsp)
mov    %r8,0x40(%rsp)
mov    %ebp,0x6c(%rsp)
jmp    1761 <MIDWT+0x631>
nopw   0x0(%rax,%rax,1)
mov    0x54(%rsp),%edi
add    %edi,%edi
mov    0x6c(%rsp),%ebp
cmp    $0x1,%ebp
cmove  %ebp,%edi
mov    0x4(%rsp),%eax
add    %eax,%eax
mov    %eax,0x4(%rsp)
mov    0x98(%rsp),%rcx
lea    -0x1(%rcx),%eax
cmp    $0x1,%ecx
mov    %eax,%r10d
jle    23c4 <MIDWT+0x1294>
mov    %r10,0x98(%rsp)
cmp    $0x2,%ebp
mov    %edi,0x54(%rsp)
mov    0x120(%rsp),%r10
jl     1e10 <MIDWT+0xce0>
cmpl   $0x0,0x4(%rsp)
jle    1e10 <MIDWT+0xce0>
mov    %edi,%eax
shr    $0x1f,%eax
add    %edi,%eax
sar    %eax
mov    %eax,0x24(%rsp)
movslq %eax,%rdx
movslq %edi,%rsi
mov    %r9,%rbx
lea    (%r8,%rdx,8),%r9
lea    0x0(,%rdx,8),%rcx
add    %r13,%rcx
lea    -0x4(%rdx),%rax
mov    %rax,0xa8(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
lea    -0x4(%rsi),%rbp
mov    %rbp,0xc0(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %rcx,0xd8(%rsp)
cmp    %rcx,%r8
setb   %r14b
mov    %r9,0xe0(%rsp)
cmp    %r9,%r13
setb   %cl
and    %r14b,%cl
mov    %cl,0xd0(%rsp)
mov    %rdx,%r9
and    $0xfffffffffffffffc,%r9
mov    %rax,%rcx
mov    %rax,0xa0(%rsp)
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rax
mov    %rax,0x148(%rsp)
mov    %rdx,%rax
neg    %rax
mov    %rax,0xf0(%rsp)
mov    %rsi,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xb8(%rsp)
lea    -0x2(%rcx),%rax
and    %rbp,%rax
mov    %rax,0x158(%rsp)
and    $0x3,%ebp
mov    %edi,%eax
and    $0x3,%eax
mov    %rax,0x100(%rsp)
mov    %rbp,0xb0(%rsp)
mov    %rbp,%r11
shl    $0x5,%r11
mov    0x4(%rsp),%eax
mov    %rax,0x108(%rsp)
lea    (%r15,%rsi,8),%rax
mov    %rax,0xe8(%rsp)
lea    (%rdx,%rdx,1),%rax
mov    %rax,0xc8(%rsp)
mov    %r9,0x168(%rsp)
lea    (%r9,%rdx,1),%rax
mov    %rax,0x160(%rsp)
mov    %rbx,%r9
mov    0x140(%rsp),%rax
mov    %rdx,0x8(%rsp)
lea    (%rax,%rdx,8),%rbp
mov    $0x1,%ecx
mov    %rcx,0x78(%rsp)
mov    0x128(%rsp),%r14
mov    0x138(%rsp),%r12
mov    %rax,0x70(%rsp)
xor    %ecx,%ecx
mov    %rsi,0x110(%rsp)
jmp    1928 <MIDWT+0x7f8>
cs nopw 0x0(%rax,%rax,1)
mov    0x88(%rsp),%rcx
add    $0x1,%rcx
mov    0x80(%rsp),%rax
add    %rax,%rbp
add    %rax,0x70(%rsp)
add    %r10,0x78(%rsp)
add    %rax,%r12
add    %rax,%r14
add    %rax,%rbx
cmp    0x108(%rsp),%rcx
je     1e10 <MIDWT+0xce0>
mov    %rbp,0x48(%rsp)
mov    %rcx,0x88(%rsp)
imul   %r10,%rcx
mov    %rcx,0x18(%rsp)
lea    (%r9,%rcx,8),%r10
cmp    $0x2,%edi
jl     1c00 <MIDWT+0xad0>
cmpl   $0x4,0x24(%rsp)
jae    1970 <MIDWT+0x840>
mov    0x8(%rsp),%rax
xor    %ecx,%ecx
testb  $0x1,0x8(%rsp)
jne    1a30 <MIDWT+0x900>
mov    %rcx,%rdx
jmp    1a75 <MIDWT+0x945>
nopl   0x0(%rax)
mov    0x8(%rsp),%rax
mov    0x18(%rsp),%rdx
add    %rdx,%rax
mov    0xc8(%rsp),%rcx
add    %rdx,%rcx
lea    (%r9,%rax,8),%rdx
mov    %r9,%rbp
lea    (%r9,%rcx,8),%rcx
cmp    %rcx,%r8
setb   %sil
mov    0xe0(%rsp),%rdi
cmp    %rdi,%rdx
setb   %al
and    %sil,%al
or     0xd0(%rsp),%al
cmp    %rdx,%r8
setb   %r9b
cmp    %rdi,%r10
setb   %dil
cmp    %rcx,%r13
setb   %cl
mov    0xd8(%rsp),%rsi
cmp    %rsi,%rdx
setb   %r8b
cmp    %rdx,%r13
setb   %dl
cmp    %rsi,%r10
setb   %sil
test   %al,%al
jne    1df4 <MIDWT+0xcc4>
and    %dil,%r9b
jne    1df4 <MIDWT+0xcc4>
and    %r8b,%cl
mov    %rbp,%r9
jne    1952 <MIDWT+0x822>
mov    0x8(%rsp),%rax
mov    $0x0,%ecx
and    %sil,%dl
mov    0x40(%rsp),%rdx
jne    1959 <MIDWT+0x829>
cmpq   $0x4,0xa8(%rsp)
jae    1b0a <MIDWT+0x9da>
xor    %eax,%eax
jmp    1b7b <MIDWT+0xa4b>
nopl   (%rax)
mov    0x18(%rsp),%rdi
lea    (%rcx,%rdi,1),%rdx
movsd  (%r9,%rdx,8),%xmm0
mov    0xf8(%rsp),%rdx
add    %rcx,%rdx
mov    0x30(%rsp),%rsi
movsd  %xmm0,(%rsi,%rdx,8)
lea    0x1(%rax),%rsi
add    %rdi,%rax
movsd  (%r9,%rax,8),%xmm0
mov    0x28(%rsp),%rax
movsd  %xmm0,(%rax,%rdx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
mov    %rsi,%rax
not    %rcx
cmp    0xf0(%rsp),%rcx
je     1c00 <MIDWT+0xad0>
mov    0x78(%rsp),%rsi
lea    (%rdx,%rsi,1),%rcx
lea    (%r9,%rcx,8),%rcx
add    %rsi,%rax
lea    (%r9,%rax,8),%rax
mov    0x8(%rsp),%rsi
sub    %rdx,%rsi
add    0x178(%rsp),%rdx
mov    0x28(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdi
mov    0x30(%rsp),%rbp
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rbp,8)
movsd  -0x8(%rax,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rbp,8)
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rsi
jne    1ad0 <MIDWT+0x9a0>
jmp    1c00 <MIDWT+0xad0>
mov    0x148(%rsp),%rcx
xor    %eax,%eax
mov    0x48(%rsp),%rsi
mov    0x70(%rsp),%rdi
xchg   %ax,%ax
movups -0x30(%rdi,%rax,8),%xmm0
movups -0x20(%rdi,%rax,8),%xmm1
movups %xmm0,(%rdx,%rax,8)
movups %xmm1,0x10(%rdx,%rax,8)
movups -0x30(%rsi,%rax,8),%xmm0
movups -0x20(%rsi,%rax,8),%xmm1
movups %xmm0,0x0(%r13,%rax,8)
movups %xmm1,0x10(%r13,%rax,8)
movups -0x10(%rdi,%rax,8),%xmm0
movups (%rdi,%rax,8),%xmm1
movups %xmm0,0x20(%rdx,%rax,8)
movups %xmm1,0x30(%rdx,%rax,8)
movups -0x10(%rsi,%rax,8),%xmm0
movups (%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%r13,%rax,8)
movups %xmm1,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b20 <MIDWT+0x9f0>
testb  $0x1,0xa0(%rsp)
01
je     1bd3 <MIDWT+0xaa3>
mov    0x8(%rsp),%rcx
add    %rax,%rcx
mov    0x18(%rsp),%rsi
lea    (%rax,%rsi,1),%rdx
movups (%r9,%rdx,8),%xmm0
movups 0x10(%r9,%rdx,8),%xmm1
add    0xf8(%rsp),%rax
mov    0x30(%rsp),%rdx
movups %xmm0,(%rdx,%rax,8)
movups %xmm1,0x10(%rdx,%rax,8)
add    %rsi,%rcx
movups (%r9,%rcx,8),%xmm0
movups 0x10(%r9,%rcx,8),%xmm1
mov    0x28(%rsp),%rcx
movups %xmm0,(%rcx,%rax,8)
movups %xmm1,0x10(%rcx,%rax,8)
mov    0x160(%rsp),%rax
mov    0x168(%rsp),%rdx
mov    %rdx,%rcx
cmp    0x8(%rsp),%rdx
jne    1959 <MIDWT+0x829>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r10,0x118(%rsp)
mov    %r15,%rdi
mov    0x24(%rsp),%esi
mov    0x60(%rsp),%rdx
mov    0x58(%rsp),%rcx
mov    0x14(%rsp),%r8d
mov    0x90(%rsp),%r9
push   0x28(%rsp)
push   0x38(%rsp)
mov    %r11,%rbp
call   1050 <bpsconv@plt>
mov    %rbp,%r11
mov    0x50(%rsp),%r8
mov    0x130(%rsp),%r10
mov    0x48(%rsp),%r9
add    $0x10,%rsp
mov    0x54(%rsp),%edi
test   %edi,%edi
mov    0x110(%rsp),%rsi
mov    0x48(%rsp),%rbp
jle    18f0 <MIDWT+0x7c0>
cmp    $0x4,%edi
jb     1c98 <MIDWT+0xb68>
mov    0x118(%rsp),%rax
cmp    0xe8(%rsp),%rax
jae    1d14 <MIDWT+0xbe4>
mov    0x18(%rsp),%rax
add    %rsi,%rax
lea    (%r9,%rax,8),%rax
cmp    %rax,%r15
jae    1d14 <MIDWT+0xbe4>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rsi,%rcx
mov    0x100(%rsp),%rdx
test   %rdx,%rdx
je     1cc5 <MIDWT+0xb95>
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1cb0 <MIDWT+0xb80>
cmp    $0x3,%rcx
jb     18f0 <MIDWT+0x7c0>
nop
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r14,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1cd0 <MIDWT+0xba0>
jmp    18f0 <MIDWT+0x7c0>
cmpq   $0xc,0xc0(%rsp)
jae    1d23 <MIDWT+0xbf3>
xor    %eax,%eax
jmp    1d98 <MIDWT+0xc68>
mov    0x158(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movups (%r15,%rax,8),%xmm0
movups 0x10(%r15,%rax,8),%xmm1
movups %xmm0,-0x70(%r12,%rax,8)
movups %xmm1,-0x60(%r12,%rax,8)
movups 0x20(%r15,%rax,8),%xmm0
movups 0x30(%r15,%rax,8),%xmm1
movups %xmm0,-0x50(%r12,%rax,8)
movups %xmm1,-0x40(%r12,%rax,8)
movups 0x40(%r15,%rax,8),%xmm0
movups 0x50(%r15,%rax,8),%xmm1
movups %xmm0,-0x30(%r12,%rax,8)
movups %xmm1,-0x20(%r12,%rax,8)
movups 0x60(%r15,%rax,8),%xmm0
movups 0x70(%r15,%rax,8),%xmm1
movups %xmm0,-0x10(%r12,%rax,8)
movups %xmm1,(%r12,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1d30 <MIDWT+0xc00>
cmpq   $0x0,0xb0(%rsp)
je     1ddb <MIDWT+0xcab>
lea    (%r14,%rax,8),%rcx
mov    0x150(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
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,%r11
jne    1dc0 <MIDWT+0xc90>
mov    0xb8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
je     18f0 <MIDWT+0x7c0>
jmp    1c9a <MIDWT+0xb6a>
mov    0x8(%rsp),%rax
xor    %ecx,%ecx
mov    %rbp,%r9
jmp    1959 <MIDWT+0x829>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %edi,%edi
jle    1730 <MIDWT+0x600>
mov    0x4(%rsp),%edx
mov    %edx,%ecx
shr    $0x1f,%ecx
add    %edx,%ecx
sar    %ecx
cmpl   $0x1,0x6c(%rsp)
sete   %r11b
mov    %ecx,0x24(%rsp)
movslq %ecx,%rbx
movslq %edx,%r12
lea    (%r8,%rbx,8),%rsi
lea    0x0(,%rbx,8),%rcx
add    %r13,%rcx
lea    -0x4(%r12),%rdi
mov    %rdi,0xd0(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
cmp    $0x4,%ebx
setae  %al
and    %r11b,%al
mov    %al,0x110(%rsp)
mov    %rcx,0xe8(%rsp)
cmp    %rcx,%r8
setb   %cl
mov    %rsi,0xf0(%rsp)
cmp    %rsi,%r13
setb   %al
and    %cl,%al
mov    %al,0xe0(%rsp)
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rbx,%rax
neg    %rax
mov    %rax,0x108(%rsp)
cmp    $0x4,%edx
setae  %al
and    %r11b,%al
mov    %al,0x78(%rsp)
mov    %r12,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xc0(%rsp)
mov    %rdi,%rax
mov    %rdi,0xc8(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
mov    %rdi,0xa0(%rsp)
mov    %edx,%eax
and    $0x3,%eax
mov    %rax,0x70(%rsp)
mov    0x80(%rsp),%rax
imul   %rbx,%rax
mov    %rax,0xb0(%rsp)
mov    0x54(%rsp),%eax
mov    %rax,0x118(%rsp)
lea    (%r15,%r12,8),%rax
mov    %rax,0x100(%rsp)
lea    (%rbx,%rbx,1),%rax
mov    %rax,0xd8(%rsp)
mov    %rcx,0xb8(%rsp)
lea    (%rcx,%rbx,1),%rax
mov    %rax,0xa8(%rsp)
xor    %r11d,%r11d
mov    0x128(%rsp),%rax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
mov    %rbx,0x18(%rsp)
jmp    1f86 <MIDWT+0xe56>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
addq   $0x8,0x8(%rsp)
add    $0x8,%r11
cmp    0x118(%rsp),%r14
mov    0x40(%rsp),%r8
mov    0x18(%rsp),%rbx
je     1730 <MIDWT+0x600>
mov    %r11,0x48(%rsp)
lea    (%r9,%r14,8),%rax
mov    %rax,0x88(%rsp)
cmpl   $0x2,0x4(%rsp)
mov    0x180(%rsp),%r11
jl     21cf <MIDWT+0x109f>
cmpb   $0x0,0x110(%rsp)
je     20d0 <MIDWT+0xfa0>
lea    (%r14,%rbx,1),%rax
mov    0xd8(%rsp),%rcx
add    %r14,%rcx
lea    (%r9,%rax,8),%rsi
lea    (%r9,%rcx,8),%rcx
cmp    %rcx,%r8
setb   %al
mov    0xf0(%rsp),%rdi
cmp    %rdi,%rsi
setb   %dl
and    %al,%dl
or     0xe0(%rsp),%dl
cmp    %rsi,%r8
setb   %al
mov    0x88(%rsp),%rbp
cmp    %rdi,%rbp
setb   %dil
cmp    %rcx,%r13
setb   %cl
mov    0xe8(%rsp),%rbx
cmp    %rbx,%rsi
setb   %r8b
cmp    %rsi,%r13
setb   %r9b
cmp    %rbx,%rbp
setb   %sil
test   %dl,%dl
jne    20d7 <MIDWT+0xfa7>
and    %dil,%al
jne    20d7 <MIDWT+0xfa7>
and    %r8b,%cl
jne    20d7 <MIDWT+0xfa7>
mov    0x18(%rsp),%rcx
mov    %rcx,%rax
mov    $0x0,%edx
and    %sil,%r9b
mov    %rcx,%rbx
mov    0x40(%rsp),%r8
mov    0x130(%rsp),%rsi
mov    0x38(%rsp),%r9
jne    20f0 <MIDWT+0xfc0>
mov    0x8(%rsp),%rax
xor    %ecx,%ecx
mov    0xb8(%rsp),%rdi
mov    0xb0(%rsp),%rdx
movups -0x10(%rax),%xmm0
movups (%rax),%xmm1
movups %xmm0,(%r8,%rcx,8)
movups %xmm1,0x10(%r8,%rcx,8)
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,0x0(%r13,%rcx,8)
movups %xmm1,0x10(%r13,%rcx,8)
add    $0x4,%rcx
add    %rsi,%rax
cmp    %rcx,%rdi
jne    2080 <MIDWT+0xf50>
mov    0xa8(%rsp),%rax
mov    %rdi,%rdx
cmp    %rbx,%rdi
jne    20f0 <MIDWT+0xfc0>
jmp    21cf <MIDWT+0x109f>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rax
xor    %edx,%edx
jmp    20f0 <MIDWT+0xfc0>
mov    0x18(%rsp),%rbx
mov    %rbx,%rax
xor    %edx,%edx
mov    0x40(%rsp),%r8
mov    0x38(%rsp),%r9
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rcx
test   $0x1,%bl
je     213f <MIDWT+0x100f>
imul   %r10,%rcx
add    %r14,%rcx
movsd  (%r9,%rcx,8),%xmm0
mov    0xf8(%rsp),%rcx
add    %rdx,%rcx
mov    0x30(%rsp),%rsi
movsd  %xmm0,(%rsi,%rcx,8)
lea    0x1(%rax),%rsi
imul   %r10,%rax
add    %r14,%rax
movsd  (%r9,%rax,8),%xmm0
mov    0x28(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
mov    %rsi,%rax
not    %rdx
cmp    0x108(%rsp),%rdx
je     21cf <MIDWT+0x109f>
mov    %r10,%rdx
imul   %rax,%rdx
add    %r14,%rdx
add    $0x1,%rax
mov    0x80(%rsp),%rdi
imul   %rdi,%rax
mov    0x48(%rsp),%rbp
add    %rbp,%rax
lea    0x1(%rcx),%rsi
imul   %rdi,%rsi
add    %rbp,%rsi
mov    %r10,%rdi
imul   %rcx,%rdi
add    %r14,%rdi
mov    %r9,%rbp
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  0x0(%rbp,%rsi,1),%xmm0
movsd  %xmm0,0x8(%r8,%rcx,8)
movsd  0x0(%rbp,%rax,1),%xmm0
movsd  %xmm0,0x8(%r13,%rcx,8)
add    $0x2,%rcx
add    %r11,%rbp
cmp    %rcx,%rbx
jne    2190 <MIDWT+0x1060>
mov    %r15,%rdi
mov    0x24(%rsp),%esi
mov    0x60(%rsp),%rdx
mov    0x58(%rsp),%rcx
mov    0x14(%rsp),%r8d
mov    0x90(%rsp),%r9
push   0x28(%rsp)
push   0x38(%rsp)
call   1050 <bpsconv@plt>
mov    0x140(%rsp),%rbx
mov    0x130(%rsp),%r10
mov    0x48(%rsp),%r9
add    $0x10,%rsp
cmpl   $0x0,0x4(%rsp)
mov    0x48(%rsp),%r11
jle    1f60 <MIDWT+0xe30>
cmpb   $0x0,0x78(%rsp)
je     2251 <MIDWT+0x1121>
mov    0x88(%rsp),%rax
cmp    0x100(%rsp),%rax
jae    2320 <MIDWT+0x11f0>
lea    (%r14,%r12,1),%rax
lea    (%r9,%rax,8),%rax
cmp    %rax,%r15
jae    2320 <MIDWT+0x11f0>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
mov    0x70(%rsp),%rsi
test   %rsi,%rsi
je     2297 <MIDWT+0x1167>
mov    %r10,%rdx
imul   %rax,%rdx
add    %r14,%rdx
lea    (%r9,%rdx,8),%rdx
mov    0x80(%rsp),%rdi
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rdx)
add    $0x1,%rax
add    %rdi,%rdx
add    $0xffffffffffffffff,%rsi
jne    2280 <MIDWT+0x1150>
cmp    $0x3,%rcx
jb     1f60 <MIDWT+0xe30>
lea    0x3(%rax),%rcx
imul   %r10,%rcx
lea    (%r9,%rcx,8),%rcx
lea    0x2(%rax),%rdx
imul   %r10,%rdx
lea    (%r9,%rdx,8),%rdx
lea    0x1(%rax),%rsi
imul   %r10,%rsi
lea    (%r9,%rsi,8),%rsi
mov    %r10,%rdi
imul   %rax,%rdi
lea    (%r9,%rdi,8),%rdi
mov    %r11,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rbp,1)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,1)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,1)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,1)
add    $0x4,%rax
add    %rbx,%rbp
cmp    %rax,%r12
jne    22e0 <MIDWT+0x11b0>
jmp    1f60 <MIDWT+0xe30>
cmpq   $0x4,0xd0(%rsp)
mov    0x170(%rsp),%rsi
jae    2337 <MIDWT+0x1207>
xor    %eax,%eax
jmp    2384 <MIDWT+0x1254>
mov    0xa0(%rsp),%rcx
mov    0x8(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups (%r15,%rax,8),%xmm0
movups 0x10(%r15,%rax,8),%xmm1
movups %xmm0,-0x10(%rdx)
movups %xmm1,(%rdx)
movups 0x20(%r15,%rax,8),%xmm0
movups 0x30(%r15,%rax,8),%xmm1
movups %xmm0,-0x10(%rdx,%rbx,1)
movups %xmm1,(%rdx,%rbx,1)
add    $0x8,%rax
add    %rsi,%rdx
add    $0xfffffffffffffffe,%rcx
jne    2350 <MIDWT+0x1220>
testb  $0x1,0xc8(%rsp)
01
je     23ab <MIDWT+0x127b>
movups (%r15,%rax,8),%xmm0
movups 0x10(%r15,%rax,8),%xmm1
imul   %r10,%rax
add    %r14,%rax
movups %xmm0,(%r9,%rax,8)
movups %xmm1,0x10(%r9,%rax,8)
mov    0xc0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
je     1f60 <MIDWT+0xe30>
jmp    2253 <MIDWT+0x1123>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %esi,%esi
test   $0x1,%r10b
jne    13a4 <MIDWT+0x274>
jmp    13dc <MIDWT+0x2ac>

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

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