MIRDWT(double *x, int m, int n, double *h, int lh, int L, double *yl,
       double *yh) {
  double *g0, *g1, *ydummyll, *ydummylh, *ydummyhl;
  double *ydummyhh, *xdummyl, *xdummyh, *xh;
  long i, j;
  int actual_L, actual_m, actual_n, c_o_a, ir, n_c, n_cb, n_c_o, lhm1;
  int ic, n_r, n_rb, n_r_o, c_o_a_p2n, sample_f;
  xh = (double *)mxCalloc(m * n, sizeof(double));
  xdummyl = (double *)mxCalloc(((m) > (n) ? (m) : (n)), sizeof(double));
  xdummyh = (double *)mxCalloc(((m) > (n) ? (m) : (n)), sizeof(double));
  ydummyll =
      (double *)mxCalloc(((m) > (n) ? (m) : (n)) + lh - 1, sizeof(double));
  ydummylh =
      (double *)mxCalloc(((m) > (n) ? (m) : (n)) + lh - 1, sizeof(double));
  ydummyhl =
      (double *)mxCalloc(((m) > (n) ? (m) : (n)) + lh - 1, sizeof(double));
  ydummyhh =
      (double *)mxCalloc(((m) > (n) ? (m) : (n)) + lh - 1, sizeof(double));
  g0 = (double *)mxCalloc(lh, sizeof(double));
  g1 = (double *)mxCalloc(lh, sizeof(double));
  if (n == 1) {
    n = m;
    m = 1;
  }
  for (i = 0; i < lh; i++) {
    g0[i] = h[i] / 2;
    g1[i] = h[lh - i - 1] / 2;
  }
  for (i = 1; i <= lh; i += 2)
    g1[i] = -g1[i];
  lhm1 = lh - 1;
  sample_f = 1;
  for (i = 1; i < L; i++)
    sample_f = sample_f * 2;
  actual_m = m / sample_f;
  actual_n = n / sample_f;
  for (i = 0; i < m * n; i++)
    x[i] = yl[i];
  for (actual_L = L; actual_L >= 1; actual_L--) {
    if (m == 1)
      c_o_a = n * (actual_L - 1);
    else
      c_o_a = 3 * n * (actual_L - 1);
    c_o_a_p2n = c_o_a + 2 * n;
    if (m > 1) {
      n_rb = m / actual_m;
      for (ic = 0; ic < n; ic++) {
        for (n_r = 0; n_r < n_rb; n_r++) {
          ir = -sample_f + n_r;
          for (i = 0; i < actual_m; i++) {
            ir = ir + sample_f;
            ydummyll[i + lhm1] = (*(x + (m * (ic) + ir)));
            ydummylh[i + lhm1] = (*(yh + (m * (c_o_a + ic) + ir)));
            ydummyhl[i + lhm1] = (*(yh + (m * (c_o_a + n + ic) + ir)));
            ydummyhh[i + lhm1] = (*(yh + (m * (c_o_a_p2n + ic) + ir)));
          }
          bpconv(xdummyl, actual_m, g0, g1, lh, ydummyll, ydummylh);
          bpconv(xdummyh, actual_m, g0, g1, lh, ydummyhl, ydummyhh);
          ir = -sample_f + n_r;
          for (i = 0; i < actual_m; i++) {
            ir = ir + sample_f;
            (*(x + (m * (ic) + ir))) = xdummyl[i];
            (*(xh + (m * (ic) + ir))) = xdummyh[i];
          }
        }
      }
    }
    n_cb = n / actual_n;
    for (ir = 0; ir < m; ir++) {
      for (n_c = 0; n_c < n_cb; n_c++) {
        ic = -sample_f + n_c;
        for (i = 0; i < actual_n; i++) {
          ic = ic + sample_f;
          ydummyll[i + lhm1] = (*(x + (m * (ic) + ir)));
          if (m > 1)
            ydummyhh[i + lhm1] = (*(xh + (m * (ic) + ir)));
          else
            ydummyhh[i + lhm1] = (*(yh + (m * (c_o_a + ic) + ir)));
        }
        bpconv(xdummyl, actual_n, g0, g1, lh, ydummyll, ydummyhh);
        ic = -sample_f + n_c;
        for (i = 0; i < actual_n; i++) {
          ic = ic + sample_f;
          (*(x + (m * (ic) + ir))) = xdummyl[i];
        }
      }
    }
    sample_f = sample_f / 2;
    actual_m = actual_m * 2;
    actual_n = actual_n * 2;
  }
}


x86 assembly (clang, -O0):
<MIRDWT>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x14(%rbp),%edi
imul   -0x18(%rbp),%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    117c <MIRDWT+0x5c>
mov    -0x14(%rbp),%eax
mov    %eax,-0xc0(%rbp)
jmp    1185 <MIRDWT+0x65>
mov    -0x18(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    11b7 <MIRDWT+0x97>
mov    -0x14(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    11c0 <MIRDWT+0xa0>
mov    -0x18(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    11f2 <MIRDWT+0xd2>
mov    -0x14(%rbp),%eax
mov    %eax,-0xc8(%rbp)
jmp    11fb <MIRDWT+0xdb>
mov    -0x18(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%edi
add    -0x24(%rbp),%edi
sub    $0x1,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    1233 <MIRDWT+0x113>
mov    -0x14(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    123c <MIRDWT+0x11c>
mov    -0x18(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%edi
add    -0x24(%rbp),%edi
sub    $0x1,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    1274 <MIRDWT+0x154>
mov    -0x14(%rbp),%eax
mov    %eax,-0xd0(%rbp)
jmp    127d <MIRDWT+0x15d>
mov    -0x18(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%edi
add    -0x24(%rbp),%edi
sub    $0x1,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    12b5 <MIRDWT+0x195>
mov    -0x14(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    12be <MIRDWT+0x19e>
mov    -0x18(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%edi
add    -0x24(%rbp),%edi
sub    $0x1,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x58(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <mxCalloc@plt>
cltq
mov    %rax,-0x38(%rbp)
cmpl   $0x1,-0x18(%rbp)
jne    131d <MIRDWT+0x1fd>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
movl   $0x1,-0x14(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
cmp    %rcx,%rax
jge    139b <MIRDWT+0x27b>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xcb5(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
sub    -0x78(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc87(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1325 <MIRDWT+0x205>
movq   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
cmp    %rcx,%rax
jg     13f6 <MIRDWT+0x2d6>
mov    -0x38(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x78(%rbp)
jmp    13a3 <MIRDWT+0x283>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
movl   $0x1,-0xbc(%rbp)
movq   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
cmp    %rcx,%rax
jge    1445 <MIRDWT+0x325>
mov    -0xbc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1414 <MIRDWT+0x2f4>
mov    -0x14(%rbp),%eax
cltd
idivl  -0xbc(%rbp)
mov    %eax,-0x88(%rbp)
mov    -0x18(%rbp),%eax
cltd
idivl  -0xbc(%rbp)
mov    %eax,-0x8c(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    14af <MIRDWT+0x38f>
mov    0x10(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    146d <MIRDWT+0x34d>
mov    -0x28(%rbp),%eax
mov    %eax,-0x84(%rbp)
cmpl   $0x1,-0x84(%rbp)
jl     1a34 <MIRDWT+0x914>
cmpl   $0x1,-0x14(%rbp)
jne    14e9 <MIRDWT+0x3c9>
mov    -0x18(%rbp),%eax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x90(%rbp)
jmp    14ff <MIRDWT+0x3df>
imul   $0x3,-0x18(%rbp),%eax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xb8(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    17ca <MIRDWT+0x6aa>
mov    -0x14(%rbp),%eax
cltd
idivl  -0x88(%rbp)
mov    %eax,-0xb0(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    17c5 <MIRDWT+0x6a5>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    17ac <MIRDWT+0x68c>
xor    %eax,%eax
sub    -0xbc(%rbp),%eax
add    -0xac(%rbp),%eax
mov    %eax,-0x94(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x88(%rbp),%rcx
cmp    %rcx,%rax
jge    169c <MIRDWT+0x57c>
mov    -0x94(%rbp),%eax
add    -0xbc(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x90(%rbp),%edx
add    -0xa8(%rbp),%edx
imul   %edx,%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x90(%rbp),%edx
add    -0x18(%rbp),%edx
add    -0xa8(%rbp),%edx
imul   %edx,%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0xb8(%rbp),%edx
add    -0xa8(%rbp),%edx
imul   %edx,%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    157e <MIRDWT+0x45e>
mov    -0x60(%rbp),%rdi
mov    -0x88(%rbp),%esi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%r8d
mov    -0x40(%rbp),%r9
mov    -0x48(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1040 <bpconv@plt>
mov    -0x68(%rbp),%rdi
mov    -0x88(%rbp),%esi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%r8d
mov    -0x50(%rbp),%r9
mov    -0x58(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1040 <bpconv@plt>
xor    %eax,%eax
sub    -0xbc(%rbp),%eax
add    -0xac(%rbp),%eax
mov    %eax,-0x94(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x88(%rbp),%rcx
cmp    %rcx,%rax
jge    1793 <MIRDWT+0x673>
mov    -0x94(%rbp),%eax
add    -0xbc(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    170a <MIRDWT+0x5ea>
jmp    1798 <MIRDWT+0x678>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1550 <MIRDWT+0x430>
jmp    17b1 <MIRDWT+0x691>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1537 <MIRDWT+0x417>
jmp    17ca <MIRDWT+0x6aa>
mov    -0x18(%rbp),%eax
cltd
idivl  -0x8c(%rbp)
mov    %eax,-0x9c(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19ee <MIRDWT+0x8ce>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    19d5 <MIRDWT+0x8b5>
xor    %eax,%eax
sub    -0xbc(%rbp),%eax
add    -0x98(%rbp),%eax
mov    %eax,-0xa8(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x8c(%rbp),%rcx
cmp    %rcx,%rax
jge    1917 <MIRDWT+0x7f7>
mov    -0xa8(%rbp),%eax
add    -0xbc(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x14(%rbp)
jle    18c6 <MIRDWT+0x7a6>
mov    -0x70(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1901 <MIRDWT+0x7e1>
mov    0x18(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x90(%rbp),%edx
add    -0xa8(%rbp),%edx
imul   %edx,%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1906 <MIRDWT+0x7e6>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    182b <MIRDWT+0x70b>
mov    -0x60(%rbp),%rdi
mov    -0x8c(%rbp),%esi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%r8d
mov    -0x40(%rbp),%r9
mov    -0x58(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1040 <bpconv@plt>
xor    %eax,%eax
sub    -0xbc(%rbp),%eax
add    -0x98(%rbp),%eax
mov    %eax,-0xa8(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x8c(%rbp),%rcx
cmp    %rcx,%rax
jge    19bc <MIRDWT+0x89c>
mov    -0xa8(%rbp),%eax
add    -0xbc(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    195c <MIRDWT+0x83c>
jmp    19c1 <MIRDWT+0x8a1>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    17fd <MIRDWT+0x6dd>
jmp    19da <MIRDWT+0x8ba>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    17e4 <MIRDWT+0x6c4>
mov    -0xbc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xbc(%rbp)
mov    -0x88(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x8c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x84(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
jmp    14b8 <MIRDWT+0x398>
mov    -0x4(%rbp),%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MIRDWT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9d,%r12d
mov    %r8d,%r15d
mov    %rcx,%r14
mov    %edx,%r13d
mov    %esi,%ebp
mov    %rdi,0x58(%rsp)
mov    %edx,%edi
imul   %esi,%edi
mov    $0x8,%esi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
mov    %eax,0x38(%rsp)
cmp    %r13d,%ebp
mov    %r13d,%ebx
cmovg  %ebp,%ebx
mov    $0x8,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
mov    %eax,0x34(%rsp)
mov    $0x8,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
mov    %eax,0x14(%rsp)
add    %r15d,%ebx
add    $0xffffffff,%ebx
mov    $0x8,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
mov    %eax,0x48(%rsp)
mov    $0x8,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
mov    %eax,0x70(%rsp)
mov    $0x8,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
mov    %eax,0x68(%rsp)
mov    $0x8,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
mov    %eax,%ebx
mov    $0x8,%esi
mov    %r15d,%edi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
cltq
mov    %rax,0x18(%rsp)
mov    $0x8,%esi
mov    %r15d,%edi
xor    %eax,%eax
call   1030 <mxCalloc@plt>
cmp    $0x1,%r13d
mov    %r13d,%r9d
cmove  %ebp,%r9d
movslq %eax,%rsi
cmove  %r13d,%ebp
mov    %ebp,0x2c(%rsp)
mov    %r15,0x50(%rsp)
test   %r15d,%r15d
mov    %r9,0x40(%rsp)
mov    %rsi,0x20(%rsp)
jle    14a7 <MIRDWT+0x387>
mov    0x50(%rsp),%rcx
movslq %ecx,%rax
cmp    $0x1,%ecx
jne    12ee <MIRDWT+0x1ce>
xor    %ecx,%ecx
mov    0x18(%rsp),%rdi
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1276 <MIRDWT+0x156>
movsd  0xdd1(%rip),%xmm0
movsd  (%r14,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
lea    (%rdx,%rax,1),%rsi
mulsd  (%r14,%rsi,8),%xmm0
mov    0x20(%rsp),%rsi
movsd  %xmm0,(%rsi,%rcx,8)
or     $0x1,%rcx
add    %rax,%rdx
je     1471 <MIRDWT+0x351>
mov    %rax,%rdx
sub    %rcx,%rdx
lea    (%r14,%rdx,8),%rdx
add    $0xfffffffffffffff8,%rdx
movsd  0xd8b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r14,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  (%rdx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
movsd  -0x8(%rdx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
add    $0xfffffffffffffff0,%rdx
cmp    %rcx,%rax
jne    12a0 <MIRDWT+0x180>
jmp    1471 <MIRDWT+0x351>
mov    %ebx,%r10d
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,8),%rcx
lea    (%rsi,%rax,8),%rdi
lea    (%r14,%rax,8),%rbp
cmp    %rdi,%rdx
setb   %r8b
cmp    %rcx,%rsi
setb   %r9b
cmp    %rbp,%rdx
setb   %dl
cmp    %r14,%rcx
mov    %rsi,%rcx
seta   %sil
cmp    %rbp,%rcx
setb   %bl
cmp    %r14,%rdi
seta   %dil
xor    %ecx,%ecx
test   %r9b,%r8b
jne    13fa <MIRDWT+0x2da>
and    %sil,%dl
jne    13fa <MIRDWT+0x2da>
and    %dil,%bl
mov    0x18(%rsp),%rdi
mov    0x40(%rsp),%r9
mov    0x20(%rsp),%rsi
mov    %r10d,%ebx
jne    123d <MIRDWT+0x11d>
mov    %rax,%rcx
and    $0xfffffffffffffffe,%rcx
lea    -0x2(%rcx),%rdx
mov    %rdx,%r8
shr    %r8
add    $0x1,%r8
test   %rdx,%rdx
je     1411 <MIRDWT+0x2f1>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    -0x2(%rax),%rbp
xor    %edx,%edx
movapd 0xc71(%rip),%xmm0
mov    0x18(%rsp),%rbx
mov    0x20(%rsp),%rsi
nopl   0x0(%rax)
movupd (%r14,%rdx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%rbx,%rdx,8)
movupd (%r14,%rbp,8),%xmm1
mulpd  %xmm0,%xmm1
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,(%rsi,%rdx,8)
movupd 0x10(%r14,%rdx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x10(%rbx,%rdx,8)
movupd -0x10(%r14,%rbp,8),%xmm1
mulpd  %xmm0,%xmm1
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,0x10(%rsi,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffc,%rbp
add    $0xfffffffffffffffe,%rdi
jne    13a0 <MIRDWT+0x280>
jmp    1418 <MIRDWT+0x2f8>
mov    0x18(%rsp),%rdi
mov    0x40(%rsp),%r9
mov    0x20(%rsp),%rsi
mov    %r10d,%ebx
jmp    123d <MIRDWT+0x11d>
xor    %edx,%edx
mov    0x18(%rsp),%rbx
test   $0x1,%r8b
mov    %rbx,%rdi
je     145b <MIRDWT+0x33b>
movupd (%r14,%rdx,8),%xmm0
movapd 0xbd1(%rip),%xmm1
mulpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rdx,8)
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
movupd -0x8(%r14,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
shufpd $0x1,%xmm0,%xmm0
mov    0x20(%rsp),%rsi
movupd %xmm0,(%rsi,%rdx,8)
cmp    %rax,%rcx
mov    0x40(%rsp),%r9
mov    0x20(%rsp),%rsi
mov    %r10d,%ebx
jne    123d <MIRDWT+0x11d>
cmpl   $0x0,0x50(%rsp)
jle    14a7 <MIRDWT+0x387>
mov    $0x1,%ecx
movapd 0xb8b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi,%rcx,8),%xmm1
xorpd  %xmm0,%xmm1
movlpd %xmm1,(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rax,%rcx
jle    1490 <MIRDWT+0x370>
mov    %r12,%r8
movslq %r8d,%r15
mov    $0x1,%r13d
cmp    $0x2,%r15d
mov    0x58(%rsp),%r11
jl     1509 <MIRDWT+0x3e9>
lea    -0x1(%r15),%rcx
lea    -0x2(%r15),%rdx
mov    %ecx,%eax
and    $0x7,%eax
cmp    $0x7,%rdx
jae    14d9 <MIRDWT+0x3b9>
mov    $0x1,%r13d
jmp    14fa <MIRDWT+0x3da>
and    $0xfffffffffffffff8,%rcx
mov    $0x1,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
shl    $0x8,%r13d
add    $0xfffffffffffffff8,%rcx
jne    14f0 <MIRDWT+0x3d0>
test   %rax,%rax
je     1509 <MIRDWT+0x3e9>
nop
add    %r13d,%r13d
add    $0xffffffffffffffff,%rax
jne    1500 <MIRDWT+0x3e0>
mov    0x2c(%rsp),%ecx
mov    %ecx,%eax
cltd
idiv   %r13d
mov    %eax,0x10(%rsp)
mov    %r9d,%eax
cltd
idiv   %r13d
mov    %eax,%esi
mov    %ecx,%r12d
imul   %r9d,%r12d
test   %r12d,%r12d
jle    16b1 <MIRDWT+0x591>
mov    0x1a0(%rsp),%rcx
movslq %r12d,%r10
cmp    $0x4,%r12d
jb     1557 <MIRDWT+0x437>
lea    (%rcx,%r10,8),%rdx
cmp    %r11,%rdx
jbe    15d0 <MIRDWT+0x4b0>
lea    (%r11,%r10,8),%rdx
cmp    %rcx,%rdx
jbe    15d0 <MIRDWT+0x4b0>
xor    %eax,%eax
mov    %rax,%rdi
not    %rdi
add    %r10,%rdi
mov    %r10,%rdx
and    $0x3,%rdx
je     1585 <MIRDWT+0x465>
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1570 <MIRDWT+0x450>
cmp    $0x3,%rdi
jb     16b1 <MIRDWT+0x591>
nop
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r11,%rax,8)
movsd  0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r11,%rax,8)
movsd  0x18(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r11,%rax,8)
add    $0x4,%rax
cmp    %rax,%r10
jne    1590 <MIRDWT+0x470>
jmp    16b1 <MIRDWT+0x591>
mov    %ebx,%edi
mov    %r10,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rbx
mov    %rbx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r9d
and    $0x3,%r9d
cmp    $0xc,%rbx
jae    15f9 <MIRDWT+0x4d9>
xor    %ebx,%ebx
jmp    1664 <MIRDWT+0x544>
and    $0xfffffffffffffffc,%rdx
xor    %ebx,%ebx
nop
movups (%rcx,%rbx,8),%xmm0
movups 0x10(%rcx,%rbx,8),%xmm1
movups %xmm0,(%r11,%rbx,8)
movups %xmm1,0x10(%r11,%rbx,8)
movups 0x20(%rcx,%rbx,8),%xmm0
movups 0x30(%rcx,%rbx,8),%xmm1
movups %xmm0,0x20(%r11,%rbx,8)
movups %xmm1,0x30(%r11,%rbx,8)
movups 0x40(%rcx,%rbx,8),%xmm0
movups 0x50(%rcx,%rbx,8),%xmm1
movups %xmm0,0x40(%r11,%rbx,8)
movups %xmm1,0x50(%r11,%rbx,8)
movupd 0x60(%rcx,%rbx,8),%xmm0
movupd 0x70(%rcx,%rbx,8),%xmm1
movupd %xmm0,0x60(%r11,%rbx,8)
movupd %xmm1,0x70(%r11,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rdx
jne    1600 <MIRDWT+0x4e0>
test   %r9,%r9
je     16a1 <MIRDWT+0x581>
lea    (%r11,%rbx,8),%r14
add    $0x10,%r14
lea    (%rcx,%rbx,8),%rdx
add    $0x10,%rdx
shl    $0x5,%r9
xor    %ebx,%ebx
nop
movupd -0x10(%rdx,%rbx,1),%xmm0
movupd (%rdx,%rbx,1),%xmm1
movupd %xmm0,-0x10(%r14,%rbx,1)
movupd %xmm1,(%r14,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1680 <MIRDWT+0x560>
cmp    %r10,%rax
mov    0x40(%rsp),%r9
mov    %edi,%ebx
jne    1559 <MIRDWT+0x439>
test   %r8d,%r8d
jle    1f88 <MIRDWT+0xe68>
movslq 0x38(%rsp),%rax
mov    %rax,0xd8(%rsp)
movslq 0x34(%rsp),%rdi
movslq 0x14(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x50(%rsp),%rax
add    $0xffffffff,%eax
movslq 0x48(%rsp),%rcx
mov    %rcx,0x48(%rsp)
movslq 0x70(%rsp),%r10
movslq 0x68(%rsp),%r11
movslq %ebx,%rbp
lea    (%r9,%r9,2),%edx
movslq %eax,%rcx
mov    0x2c(%rsp),%r14d
mov    %r8,%rbx
movslq %r14d,%r8
mov    %edx,0xec(%rsp)
movslq %edx,%rdx
lea    (%rbx,%rbx,2),%eax
add    $0xffffffff,%eax
imul   %r12d,%eax
mov    %eax,0x90(%rsp)
lea    (%r12,%r12,2),%eax
mov    %eax,0xf0(%rsp)
lea    (%rbx,%rbx,2),%eax
add    $0xfffffffe,%eax
imul   %r12d,%eax
mov    %eax,0x8c(%rsp)
lea    -0x1(%r15),%rax
imul   %r8,%rax
imul   %rdx,%rax
mov    0x1a8(%rsp),%r12
lea    (%r12,%rax,8),%rbx
imul   %r8,%rdx
shl    $0x3,%rdx
neg    %rdx
mov    %rdx,0x128(%rsp)
mov    %rbp,0x68(%rsp)
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
mov    %r11,0x100(%rsp)
lea    (%r11,%rcx,8),%rdx
mov    %rdx,0x160(%rsp)
mov    %r10,0x108(%rsp)
lea    (%r10,%rcx,8),%rdx
mov    %rdx,0x158(%rsp)
mov    0x48(%rsp),%rdx
lea    (%rdx,%rcx,8),%r10
mov    %r8,%rcx
shl    $0x4,%rcx
mov    %rcx,0x120(%rsp)
mov    %r9d,%ecx
mov    %rcx,0x148(%rsp)
mov    %r14d,%ecx
mov    %rcx,0x150(%rsp)
mov    %r8,0xe0(%rsp)
lea    0x0(,%r8,8),%rcx
mov    %rcx,0xf8(%rsp)
mov    %rax,%r8
mov    %rdi,0x70(%rsp)
mov    %rax,0x118(%rsp)
mov    %r10,0x110(%rsp)
jmp    1870 <MIRDWT+0x750>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x94(%rsp),%ecx
mov    %ecx,%r13d
shr    $0x1f,%r13d
add    %ecx,%r13d
sar    %r13d
mov    0x10(%rsp),%ecx
add    %ecx,%ecx
mov    %ecx,0x10(%rsp)
add    %esi,%esi
mov    0x138(%rsp),%rdx
lea    -0x1(%rdx),%r15
mov    0xf0(%rsp),%ebp
sub    %ebp,0x90(%rsp)
sub    %ebp,0x8c(%rsp)
mov    0x130(%rsp),%rbx
add    0x128(%rsp),%rbx
cmp    $0x1,%rdx
mov    0x40(%rsp),%r9
jle    1f88 <MIRDWT+0xe68>
mov    0x2c(%rsp),%ecx
cmp    $0x1,%ecx
mov    %r13d,0x94(%rsp)
mov    %esi,0x14(%rsp)
mov    %r15,0x138(%rsp)
mov    %rbx,0x130(%rsp)
lea    -0x1(%r15),%ebp
jne    18b0 <MIRDWT+0x790>
imul   %r9d,%ebp
movl   $0x0,0x3c(%rsp)
jmp    1cd0 <MIRDWT+0xbb0>
nopw   0x0(%rax,%rax,1)
imul   0xec(%rsp),%ebp
cmp    $0x2,%ecx
jl     1cb0 <MIRDWT+0xb90>
mov    %ecx,%eax
cltd
mov    0x10(%rsp),%r11d
idiv   %r11d
mov    %eax,0x30(%rsp)
mov    $0x1,%al
mov    %eax,0x3c(%rsp)
test   %r9d,%r9d
mov    0x58(%rsp),%rax
jle    1cd0 <MIRDWT+0xbb0>
mov    %ebp,0xe8(%rsp)
movslq %r11d,%r9
mov    %r13d,%ecx
neg    %ecx
mov    %ecx,0xf4(%rsp)
movslq %r13d,%r14
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xc0(%rsp)
mov    0x1a8(%rsp),%rdx
lea    (%rdx,%r14,8),%rcx
mov    %rcx,0x140(%rsp)
lea    (%rbx,%r14,8),%r12
lea    (%rax,%r14,8),%r13
mov    %r14,%rcx
shl    $0x4,%rcx
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rcx,1),%rbx
mov    %rbx,0xa8(%rsp)
add    %rax,%rcx
mov    %rcx,0xb0(%rsp)
lea    (%rdx,%r14,8),%rax
mov    0x8c(%rsp),%ecx
mov    %ecx,0x9c(%rsp)
mov    0x90(%rsp),%ecx
mov    %ecx,0x98(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x78(%rsp)
mov    %r11d,%ebp
mov    %rax,%r11
mov    %r9,0x80(%rsp)
jmp    19e2 <MIRDWT+0x8c2>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x78(%rsp),%rcx
add    $0x1,%rcx
mov    0x2c(%rsp),%eax
add    %eax,0x98(%rsp)
add    %eax,0x9c(%rsp)
mov    0xf8(%rsp),%rax
add    %rax,%r12
add    %rax,%r13
add    %rax,0xa8(%rsp)
add    %rax,0xb0(%rsp)
add    %rax,%r11
mov    %rcx,%rax
mov    %rcx,0x78(%rsp)
cmp    0x148(%rsp),%rcx
je     1cba <MIRDWT+0xb9a>
cmpl   $0x0,0x30(%rsp)
jle    1990 <MIRDWT+0x870>
movslq 0x98(%rsp),%rax
mov    0x140(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0xd0(%rsp)
movslq 0x9c(%rsp),%rax
lea    (%rcx,%rax,8),%r15
mov    0x78(%rsp),%rax
imul   0xe0(%rsp),%rax
mov    %rax,0xc8(%rsp)
xor    %eax,%eax
mov    0xf4(%rsp),%ecx
mov    %r12,0x60(%rsp)
mov    %r11,0xb8(%rsp)
jmp    1af9 <MIRDWT+0x9d9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x108(%rsp),%rax
mov    %rax,(%rsp)
mov    %ebp,%esi
mov    0x18(%rsp),%r12
mov    %r12,%rdx
mov    0x20(%rsp),%rbp
mov    %rbp,%rcx
mov    0x50(%rsp),%rbx
mov    %ebx,%r8d
mov    0x48(%rsp),%r9
xor    %eax,%eax
call   1040 <bpconv@plt>
mov    0x68(%rsp),%rax
mov    %rax,(%rsp)
mov    0xa0(%rsp),%rdi
mov    0x10(%rsp),%esi
mov    %r12,%rdx
mov    %rbp,%rcx
mov    0x10(%rsp),%ebp
mov    %ebx,%r8d
mov    0x100(%rsp),%r9
xor    %eax,%eax
call   1040 <bpconv@plt>
mov    0xb8(%rsp),%r11
mov    0x80(%rsp),%r9
mov    0x70(%rsp),%rdi
mov    0x14(%rsp),%esi
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    0x34(%rsp),%ecx
add    $0x1,%ecx
cmp    0x30(%rsp),%eax
mov    0x118(%rsp),%r8
mov    0x110(%rsp),%r10
mov    0x60(%rsp),%r12
je     1990 <MIRDWT+0x870>
mov    %eax,0x38(%rsp)
test   %ebp,%ebp
mov    %ecx,0x34(%rsp)
jle    1a50 <MIRDWT+0x930>
mov    %ebp,%esi
movslq %ecx,%rbx
mov    %rbx,%rcx
xor    %eax,%eax
mov    0x160(%rsp),%r11
mov    0x158(%rsp),%rdx
mov    0xd0(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
movsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movsd  0x0(%rbp,%rcx,8),%xmm0
add    %r14,%rcx
movsd  %xmm0,(%r8,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    1b30 <MIRDWT+0xa10>
mov    0x108(%rsp),%rax
mov    %rax,(%rsp)
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%r12
mov    %r12,%rcx
mov    0x50(%rsp),%rbp
mov    %ebp,%r8d
mov    0x48(%rsp),%r9
xor    %eax,%eax
call   1040 <bpconv@plt>
mov    0x68(%rsp),%rax
mov    %rax,(%rsp)
mov    0xa0(%rsp),%rdi
mov    0x10(%rsp),%esi
mov    0x18(%rsp),%rdx
mov    %r12,%rcx
mov    %ebp,%r8d
mov    0x10(%rsp),%ebp
mov    0x100(%rsp),%r9
xor    %eax,%eax
call   1040 <bpconv@plt>
mov    0x80(%rsp),%r9
mov    0x70(%rsp),%rdi
test   %ebp,%ebp
mov    0x14(%rsp),%esi
mov    0xb8(%rsp),%r11
jle    1acc <MIRDWT+0x9ac>
mov    %ebp,%r12d
cmp    $0x1,%ebp
jne    1bf9 <MIRDWT+0xad9>
xor    %eax,%eax
jmp    1c62 <MIRDWT+0xb42>
mov    %rbx,%rcx
xor    %eax,%eax
mov    0xa0(%rsp),%rdx
mov    0xc0(%rsp),%r8
mov    0xb0(%rsp),%r10
mov    0xa8(%rsp),%rbp
xchg   %ax,%ax
lea    (%rcx,%r14,1),%rbx
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rcx,8)
add    %r14,%rbx
movsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x2,%rax
mov    %rbx,%rcx
cmp    %rax,%r8
jne    1c20 <MIRDWT+0xb00>
test   $0x1,%r9b
mov    %r12d,%ebp
je     1acc <MIRDWT+0x9ac>
add    %r14,%rbx
movsd  (%rdi,%rax,8),%xmm0
add    0xc8(%rsp),%rbx
mov    0x58(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbx,8)
mov    0xa0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0xd8(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
jmp    1acc <MIRDWT+0x9ac>
nopl   0x0(%rax,%rax,1)
movl   $0x0,0x3c(%rsp)
jmp    1cd0 <MIRDWT+0xbb0>
mov    0x40(%rsp),%r9
mov    0x2c(%rsp),%ecx
mov    0xe8(%rsp),%ebp
nopw   0x0(%rax,%rax,1)
mov    %r9d,%eax
cltd
idiv   %esi
mov    %eax,0x30(%rsp)
test   %ecx,%ecx
mov    0x3c(%rsp),%r9d
jle    1810 <MIRDWT+0x6f0>
movslq %esi,%r14
mov    0x94(%rsp),%eax
mov    %eax,%ecx
neg    %ecx
mov    %ecx,0x78(%rsp)
movslq %eax,%r11
movslq %ebp,%rax
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xc8(%rsp)
add    %r11,%rax
mov    %rax,0xb0(%rsp)
mov    0xf8(%rsp),%r15
imul   %r11,%r15
lea    (%r11,%r11,1),%rax
mov    %rax,0xa8(%rsp)
mov    0x120(%rsp),%rax
imul   %r11,%rax
mov    %rax,0xc0(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,0x80(%rsp)
xor    %eax,%eax
mov    %rax,0x60(%rsp)
mov    %r11,0xd0(%rsp)
jmp    1d98 <MIRDWT+0xc78>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x60(%rsp),%rcx
add    $0x1,%rcx
addq   $0x8,0x80(%rsp)
mov    %rcx,%rax
mov    %rcx,0x60(%rsp)
cmp    0x150(%rsp),%rcx
je     1810 <MIRDWT+0x6f0>
cmpl   $0x0,0x30(%rsp)
jle    1d70 <MIRDWT+0xc50>
xor    %eax,%eax
mov    0x78(%rsp),%ecx
jmp    1e10 <MIRDWT+0xcf0>
nopw   0x0(%rax,%rax,1)
mov    0x68(%rsp),%rax
mov    %rax,(%rsp)
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    0x50(%rsp),%r8
mov    0x48(%rsp),%r9
xor    %eax,%eax
mov    %r11,%rbx
call   1040 <bpconv@plt>
mov    %rbx,%r11
mov    0x70(%rsp),%rdi
mov    0x14(%rsp),%esi
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    0x34(%rsp),%ecx
add    $0x1,%ecx
cmp    0x30(%rsp),%eax
mov    0x118(%rsp),%r8
mov    0x110(%rsp),%r10
mov    0x3c(%rsp),%r9d
je     1d70 <MIRDWT+0xc50>
mov    %eax,0x38(%rsp)
test   %esi,%esi
mov    %ecx,0x34(%rsp)
jle    1db0 <MIRDWT+0xc90>
movslq %ecx,%r13
mov    0xa8(%rsp),%rax
add    %r13,%rax
mov    0xe0(%rsp),%rbp
imul   %rbp,%rax
lea    (%r11,%r13,1),%rcx
imul   %rbp,%rcx
mov    0x60(%rsp),%rbx
add    %rbx,%rcx
mov    0xb0(%rsp),%rdx
add    %r13,%rdx
imul   %rbp,%rdx
add    %rbx,%rdx
mov    0x80(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    %rax,0xb8(%rsp)
mov    0x58(%rsp),%rax
lea    (%rax,%rcx,8),%r12
mov    0x1a8(%rsp),%rax
lea    (%rax,%rdx,8),%rbp
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
xor    %edx,%edx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,1),%xmm0
movsd  %xmm0,(%r10,%rbx,8)
test   %r9b,%r9b
mov    %rbp,%rax
cmovne %rcx,%rax
movsd  (%rax,%rdx,1),%xmm0
movsd  %xmm0,(%r8,%rbx,8)
add    $0x1,%rbx
add    %r15,%rdx
cmp    %rbx,%r14
jne    1ea0 <MIRDWT+0xd80>
mov    0x68(%rsp),%rax
mov    %rax,(%rsp)
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    0x50(%rsp),%r8
mov    0x48(%rsp),%r9
xor    %eax,%eax
call   1040 <bpconv@plt>
mov    0x70(%rsp),%rdi
mov    0x14(%rsp),%esi
test   %esi,%esi
mov    0xd0(%rsp),%r11
jle    1de3 <MIRDWT+0xcc3>
cmp    $0x1,%esi
jne    1f13 <MIRDWT+0xdf3>
xor    %eax,%eax
jmp    1f58 <MIRDWT+0xe38>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0xc8(%rsp),%rdx
mov    0xc0(%rsp),%rbp
mov    0xb8(%rsp),%rbx
nop
add    %r11,%r13
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rcx,1)
add    %r11,%r13
movsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,1)
add    $0x2,%rax
add    %rbp,%rcx
cmp    %rax,%rdx
jne    1f30 <MIRDWT+0xe10>
test   $0x1,%r14b
je     1de3 <MIRDWT+0xcc3>
add    %r11,%r13
movsd  (%rdi,%rax,8),%xmm0
imul   0xe0(%rsp),%r13
add    0x60(%rsp),%r13
mov    0x58(%rsp),%rax
movsd  %xmm0,(%rax,%r13,8)
jmp    1de3 <MIRDWT+0xcc3>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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