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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ dyaddown_1D_keep_even(double *, int, double *, int);
int /*<<< orphan*/ dyaddown_1D_keep_odd(double *, int, double *, int);
scalar_t__ floor(int);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ i_conv(double *, int, double *, int, double *, int);
double *malloc(int);
void iswt_conv(double *approx, double *detail, int sigInLength, double *sigOut,
               int sigOutLength, double *filterLow, double *filterHi,
               int filterLength) {
  int length1, length2, count;
  double *approxTempOdd, *detailTempOdd;
  double *approxTempEven, *detailTempEven;
  double *approxOutOdd, *detailOutOdd;
  double *approxOutEven, *detailOutEven;
  double *approxT, *detailT;
  double *sigOdd, *sigEven;
  length1 = (int)floor(sigInLength / 2.0);
  approxTempOdd = malloc(length1 * sizeof(double));
  detailTempOdd = malloc(length1 * sizeof(double));
  approxTempEven = malloc(length1 * sizeof(double));
  detailTempEven = malloc(length1 * sizeof(double));
  dyaddown_1D_keep_odd(approx, sigInLength, approxTempOdd, length1);
  dyaddown_1D_keep_even(approx, sigInLength, approxTempEven, length1);
  dyaddown_1D_keep_odd(detail, sigInLength, detailTempOdd, length1);
  dyaddown_1D_keep_even(detail, sigInLength, detailTempEven, length1);
  length2 = 2 * length1;
  approxOutOdd = malloc(length2 * sizeof(double));
  approxOutEven = malloc(length2 * sizeof(double));
  detailOutOdd = malloc(length2 * sizeof(double));
  detailOutEven = malloc(length2 * sizeof(double));
  for (count = 0; count < length1; count++) {
    approxOutOdd[2 * count] = approxTempOdd[count];
    detailOutOdd[2 * count] = detailTempOdd[count];
    approxOutOdd[2 * count + 1] = 0;
    detailOutOdd[2 * count + 1] = 0;
    approxOutEven[2 * count] = 0;
    detailOutEven[2 * count] = 0;
    approxOutEven[2 * count + 1] = approxTempEven[count];
    detailOutEven[2 * count + 1] = detailTempEven[count];
  }
  free(approxTempOdd);
  free(detailTempOdd);
  free(approxTempEven);
  free(detailTempEven);
  approxT = malloc(length2 * sizeof(double));
  detailT = malloc(length2 * sizeof(double));
  sigOdd = malloc(length2 * sizeof(double));
  sigEven = malloc(length2 * sizeof(double));
  i_conv(approxOutOdd, length2, approxT, length2, filterLow, filterLength);
  i_conv(detailOutOdd, length2, detailT, length2, filterHi, filterLength);
  for (count = 0; count < length2; count++)
    sigOdd[count] = approxT[count] + detailT[count];
  free(approxOutOdd);
  free(detailOutOdd);
  i_conv(approxOutEven, length2, approxT, length2, filterLow, filterLength);
  i_conv(detailOutEven, length2, detailT, length2, filterHi, filterLength);
  for (count = 0; count < length2; count++)
    sigEven[count] = approxT[count] + detailT[count];
  free(approxOutEven);
  free(detailOutEven);
  free(approxT);
  free(detailT);
  for (count = (sigOutLength - filterLength - 1); count < sigOutLength; count++)
    sigOut[count + 1 + filterLength - sigOutLength] =
        (sigOdd[count] + sigEven[count]) / 2.0;
  for (count = 0; count < (sigOutLength - filterLength - 1); count++)
    sigOut[count + filterLength + 1] = (sigOdd[count] + sigEven[count]) / 2.0;
  free(sigOdd);
  free(sigEven);
  return;
}


x86 assembly (clang, -O0):
<iswt_conv>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  0xe6a(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <floor@plt>
mov    %eax,-0x34(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x48(%rbp),%rdx
mov    -0x34(%rbp),%ecx
call   1070 <dyaddown_1D_keep_odd@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x58(%rbp),%rdx
mov    -0x34(%rbp),%ecx
call   1050 <dyaddown_1D_keep_even@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x34(%rbp),%ecx
call   1070 <dyaddown_1D_keep_odd@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    -0x34(%rbp),%ecx
call   1050 <dyaddown_1D_keep_even@plt>
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1390 <iswt_conv+0x230>
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    129a <iswt_conv+0x13a>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%r8
mov    0x18(%rbp),%r9d
call   1060 <i_conv@plt>
mov    -0x70(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x90(%rbp),%rdx
mov    -0x38(%rbp),%ecx
mov    0x10(%rbp),%r8
mov    0x18(%rbp),%r9d
call   1060 <i_conv@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1499 <iswt_conv+0x339>
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    144f <iswt_conv+0x2ef>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%r8
mov    0x18(%rbp),%r9d
call   1060 <i_conv@plt>
mov    -0x80(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x90(%rbp),%rdx
mov    -0x38(%rbp),%ecx
mov    0x10(%rbp),%r8
mov    0x18(%rbp),%r9d
call   1060 <i_conv@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1538 <iswt_conv+0x3d8>
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ee <iswt_conv+0x38e>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x24(%rbp),%eax
sub    0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15cc <iswt_conv+0x46c>
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xa5e(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
add    0x18(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    156e <iswt_conv+0x40e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1636 <iswt_conv+0x4d6>
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x9f1(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15d3 <iswt_conv+0x473>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<iswt_conv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,0x30(%rsp)
mov    %r8d,0x54(%rsp)
mov    %rcx,0x58(%rsp)
mov    %edx,%r12d
mov    %rsi,0x10(%rsp)
mov    %rdi,%r14
mov    0xa8(%rsp),%eax
mov    %rax,0x48(%rsp)
mov    0xa0(%rsp),%rax
mov    %rax,0x60(%rsp)
cvtsi2sd %edx,%xmm0
mulsd  0xe53(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1080 <floor@plt>
mov    %rax,0x18(%rsp)
lea    0x0(,%rax,8),%ebp
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    %r14,%rdi
mov    %r12d,%esi
mov    0x8(%rsp),%rdx
mov    0x18(%rsp),%rbp
mov    %ebp,%ecx
call   1070 <dyaddown_1D_keep_odd@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %rbx,%rdx
mov    %ebp,%ecx
call   1050 <dyaddown_1D_keep_even@plt>
mov    0x10(%rsp),%r14
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r15,%rdx
mov    %ebp,%ecx
call   1070 <dyaddown_1D_keep_odd@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r13,%rdx
mov    %ebp,%ecx
call   1050 <dyaddown_1D_keep_even@plt>
lea    0x0(%rbp,%rbp,1),%eax
mov    %eax,0x10(%rsp)
mov    %ebp,%r14d
shl    $0x4,%r14d
mov    %r14d,%edi
call   1040 <malloc@plt>
mov    %rax,%r12
mov    %r14d,%edi
call   1040 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %r14d,%edi
call   1040 <malloc@plt>
mov    %rax,%rbp
mov    %r14d,0x28(%rsp)
mov    %r14d,%edi
call   1040 <malloc@plt>
mov    0x8(%rsp),%rdi
mov    0x40(%rsp),%rdx
cmpl   $0x0,0x18(%rsp)
jle    12fa <iswt_conv+0x19a>
mov    0x18(%rsp),%esi
shl    $0x3,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rcx,1),%xmm0
movsd  %xmm0,(%r12,%rcx,2)
movsd  (%r15,%rcx,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,2)
movq   $0x0,0x8(%r12,%rcx,2)
movq   $0x0,0x8(%rbp,%rcx,2)
movq   $0x0,(%rdx,%rcx,2)
movq   $0x0,(%rax,%rcx,2)
movsd  (%rbx,%rcx,1),%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,2)
movsd  0x0(%r13,%rcx,1),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,2)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    12a0 <iswt_conv+0x140>
mov    %rax,0x38(%rsp)
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%ebx
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r12,%rdi
mov    0x10(%rsp),%r13d
mov    %r13d,%esi
mov    %r14,%rdx
mov    %r13d,%ecx
mov    0x30(%rsp),%r8
mov    0x48(%rsp),%rbx
mov    %ebx,%r9d
call   1060 <i_conv@plt>
mov    %rbp,%rdi
mov    %r13d,%esi
mov    %r15,%rdx
mov    %r13d,%ecx
mov    0x60(%rsp),%r13
mov    %r13,%r8
mov    %ebx,%r9d
call   1060 <i_conv@plt>
cmpl   $0x0,0x18(%rsp)
jle    13b2 <iswt_conv+0x252>
mov    0x10(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
cmp    $0x4,%edx
jae    1410 <iswt_conv+0x2b0>
xor    %eax,%eax
mov    0x20(%rsp),%r13
jmp    14f0 <iswt_conv+0x390>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rbp
mov    %rbp,%rdi
mov    0x10(%rsp),%ebx
mov    %ebx,%esi
mov    %r14,%rdx
mov    %ebx,%ecx
mov    0x30(%rsp),%r8
mov    0x48(%rsp),%r12
mov    %r12d,%r9d
call   1060 <i_conv@plt>
mov    0x38(%rsp),%rdi
mov    %ebx,%esi
mov    %r15,%rdx
mov    %ebx,%ecx
mov    %r13,%r8
mov    %r12d,%r9d
call   1060 <i_conv@plt>
mov    %rbp,%rdi
mov    0x58(%rsp),%rbx
mov    0x20(%rsp),%r13
jmp    167b <iswt_conv+0x51b>
mov    %edx,%eax
and    $0x7ffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
mov    0x20(%rsp),%r13
je     1956 <iswt_conv+0x7f6>
mov    %rdi,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   (%rax)
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rcx,8)
movupd %xmm0,0x10(%r13,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm0
movupd 0x30(%r14,%rcx,8),%xmm1
movupd 0x20(%r15,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%r15,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r13,%rcx,8)
movupd %xmm0,0x30(%r13,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1440 <iswt_conv+0x2e0>
test   $0x1,%dil
je     14e2 <iswt_conv+0x382>
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rcx,8)
movupd %xmm0,0x10(%r13,%rcx,8)
cmp    %rdx,%rax
je     150c <iswt_conv+0x3ac>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    14f0 <iswt_conv+0x390>
mov    %r12,%rdi
mov    %rdx,0x28(%rsp)
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rbx
mov    %rbx,%rdi
mov    0x10(%rsp),%ebp
mov    %ebp,%esi
mov    %r14,%rdx
mov    %ebp,%ecx
mov    0x30(%rsp),%r8
mov    0x48(%rsp),%r12
mov    %r12d,%r9d
call   1060 <i_conv@plt>
mov    0x38(%rsp),%rdi
mov    %ebp,%esi
mov    %r15,%rdx
mov    %ebp,%ecx
mov    0x60(%rsp),%r8
mov    %r12d,%r9d
call   1060 <i_conv@plt>
mov    0x28(%rsp),%rdx
mov    %rbx,%rdi
cmpl   $0x0,0x18(%rsp)
mov    0x58(%rsp),%rbx
mov    0x8(%rsp),%rbp
jle    167b <iswt_conv+0x51b>
cmp    $0x4,%edx
jae    1588 <iswt_conv+0x428>
xor    %eax,%eax
jmp    1660 <iswt_conv+0x500>
mov    %edx,%eax
and    $0x7ffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1967 <iswt_conv+0x807>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm0,0x10(%rbp,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm0
movupd 0x30(%r14,%rcx,8),%xmm1
movupd 0x20(%r15,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%r15,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbp,%rcx,8)
movupd %xmm0,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15b0 <iswt_conv+0x450>
test   $0x1,%r8b
je     164c <iswt_conv+0x4ec>
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm0,0x10(%rbp,%rcx,8)
cmp    %rdx,%rax
je     167b <iswt_conv+0x51b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1660 <iswt_conv+0x500>
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12d,%r10d
not    %r10d
mov    0x54(%rsp),%ecx
add    %ecx,%r10d
cmp    %ecx,%r10d
jge    1810 <iswt_conv+0x6b0>
movslq %r10d,%rdx
cmp    $0x3,%r12d
jge    16c1 <iswt_conv+0x561>
mov    %rdx,%r11
jmp    1754 <iswt_conv+0x5f4>
mov    %r12d,%r9d
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    (%r8,%rdx,1),%r11
lea    0x0(,%r9,8),%rdi
and    $0xffffffffffffffe0,%rdi
lea    0x10(,%rdx,8),%rbp
add    %r13,%rbp
mov    0x8(%rsp),%rax
lea    (%rax,%rdx,8),%rsi
add    $0x10,%rsi
xor    %edx,%edx
movapd 0x90f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rbp,%rdx,1),%xmm1
movupd 0x0(%rbp,%rdx,1),%xmm2
movupd -0x10(%rsi,%rdx,1),%xmm3
addpd  %xmm1,%xmm3
movupd (%rsi,%rdx,1),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
movupd %xmm3,(%rbx,%rdx,1)
movupd %xmm1,0x10(%rbx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1710 <iswt_conv+0x5b0>
cmp    %r8,%r9
je     1810 <iswt_conv+0x6b0>
mov    %ecx,%esi
sub    %r11d,%esi
mov    %r11d,%edx
not    %edx
test   $0x1,%sil
je     1792 <iswt_conv+0x632>
mov    %r12d,%esi
sub    %ecx,%esi
movsd  0x0(%r13,%r11,8),%xmm0
mov    0x8(%rsp),%rax
addsd  (%rax,%r11,8),%xmm0
mulsd  0x87d(%rip),%xmm0
add    $0x1,%r11
add    %r11d,%esi
movslq %esi,%rsi
movsd  %xmm0,(%rbx,%rsi,8)
add    %ecx,%edx
je     1810 <iswt_conv+0x6b0>
mov    %ecx,%edx
sub    %r11d,%edx
lea    (%r12,%r11,1),%esi
sub    %ecx,%esi
lea    0x8(,%r11,8),%rdi
add    %r13,%rdi
mov    0x8(%rsp),%rax
lea    (%rax,%r11,8),%rcx
add    $0x8,%rcx
xor    %ebp,%ebp
movsd  0x83d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rdi,%rbp,8),%xmm1
addsd  -0x8(%rcx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
lea    (%rsi,%rbp,1),%eax
add    $0x1,%eax
cltq
movsd  %xmm1,(%rbx,%rax,8)
movsd  (%rdi,%rbp,8),%xmm1
addsd  (%rcx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
lea    (%rsi,%rbp,1),%eax
add    $0x2,%eax
cltq
movsd  %xmm1,(%rbx,%rax,8)
add    $0x2,%rbp
cmp    %ebp,%edx
jne    17d0 <iswt_conv+0x670>
test   %r10d,%r10d
mov    0x8(%rsp),%rbp
jle    1938 <iswt_conv+0x7d8>
mov    %r10d,%ecx
cmp    $0x4,%r10d
jae    182e <iswt_conv+0x6ce>
xor    %eax,%eax
jmp    18ad <iswt_conv+0x74d>
lea    -0x1(%rcx),%rsi
lea    0x1(%r12),%edx
lea    (%r12,%rsi,1),%edi
add    $0x1,%edi
xor    %eax,%eax
cmp    %edx,%edi
jl     18ad <iswt_conv+0x74d>
shr    $0x20,%rsi
jne    18ad <iswt_conv+0x74d>
mov    %ecx,%eax
and    $0xfffffffc,%eax
mov    %edx,%edx
xor    %esi,%esi
movapd 0x7b5(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rsi,8),%xmm1
movupd 0x10(%r13,%rsi,8),%xmm2
movupd 0x0(%rbp,%rsi,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%rbp,%rsi,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
lea    (%rdx,%rsi,1),%edi
movslq %edi,%rdi
movupd %xmm3,(%rbx,%rdi,8)
movupd %xmm1,0x10(%rbx,%rdi,8)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    1860 <iswt_conv+0x700>
cmp    %rcx,%rax
je     1938 <iswt_conv+0x7d8>
mov    %rax,%rdx
not    %rdx
test   $0x1,%cl
je     18dd <iswt_conv+0x77d>
movsd  0x0(%r13,%rax,8),%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
mulsd  0x733(%rip),%xmm0
or     $0x1,%rax
lea    (%rax,%r12,1),%esi
movslq %esi,%rsi
movsd  %xmm0,(%rbx,%rsi,8)
add    %rcx,%rdx
je     1938 <iswt_conv+0x7d8>
mov    %r12d,%edx
movsd  0x713(%rip),%xmm0
mov    %rax,%rsi
movsd  0x0(%r13,%rax,8),%xmm1
addsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
lea    (%rdx,%rax,1),%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  %xmm1,(%rbx,%rdi,8)
movsd  0x8(%r13,%rax,8),%xmm1
addsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
add    $0x2,%rsi
add    %edx,%eax
add    $0x2,%eax
cltq
movsd  %xmm1,(%rbx,%rax,8)
mov    %rsi,%rax
cmp    %rsi,%rcx
jne    18f0 <iswt_conv+0x790>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %ecx,%ecx
test   $0x1,%dil
jne    14b2 <iswt_conv+0x352>
jmp    14e2 <iswt_conv+0x382>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    161e <iswt_conv+0x4be>
jmp    164c <iswt_conv+0x4ec>

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

LLVM IR (-O2):
define void @iswt_conv(double* %0, double* %1, i32 %2, double* nocapture writeonly %3, i32 %4, double* %5, double* %6, i32 %7) {
%9 = sitofp i32 %2 to double
%10 = fmul double %9, 5.000000e-01
%11 = fptosi double %10 to i32
%12 = tail call i64 @floor(i32 %11)
%13 = trunc i64 %12 to i32
%14 = shl i32 %13, 3
%15 = tail call double* @malloc(i32 %14)
%16 = tail call double* @malloc(i32 %14)
%17 = tail call double* @malloc(i32 %14)
%18 = tail call double* @malloc(i32 %14)
%19 = tail call i32 @dyaddown_1D_keep_odd(double* %0, i32 %2, double* %15, i32 %13)
%20 = tail call i32 @dyaddown_1D_keep_even(double* %0, i32 %2, double* %17, i32 %13)
%21 = tail call i32 @dyaddown_1D_keep_odd(double* %1, i32 %2, double* %16, i32 %13)
%22 = tail call i32 @dyaddown_1D_keep_even(double* %1, i32 %2, double* %18, i32 %13)
%23 = shl i32 %13, 1
%24 = shl i32 %13, 4
%25 = tail call double* @malloc(i32 %24)
%26 = tail call double* @malloc(i32 %24)
%27 = tail call double* @malloc(i32 %24)
%28 = tail call double* @malloc(i32 %24)
%29 = icmp sgt i32 %13, 0
br i1 %29, label %30, label %54
30: ; preds = %8
%31 = and i64 %12, 4294967295
br label %32
32: ; preds = %30, %32
%33 = phi i64 [ 0, %30 ], [ %52, %32 ]
%34 = getelementptr inbounds double, double* %15, i64 %33
%35 = load double, double* %34
%36 = shl nuw nsw i64 %33, 1
%37 = getelementptr inbounds double, double* %25, i64 %36
store double %35, double* %37
%38 = getelementptr inbounds double, double* %16, i64 %33
%39 = load double, double* %38
%40 = getelementptr inbounds double, double* %27, i64 %36
store double %39, double* %40
%41 = or i64 %36, 1
%42 = getelementptr inbounds double, double* %25, i64 %41
store double 0.000000e+00, double* %42
%43 = getelementptr inbounds double, double* %27, i64 %41
store double 0.000000e+00, double* %43
%44 = getelementptr inbounds double, double* %26, i64 %36
store double 0.000000e+00, double* %44
%45 = getelementptr inbounds double, double* %28, i64 %36
store double 0.000000e+00, double* %45
%46 = getelementptr inbounds double, double* %17, i64 %33
%47 = load double, double* %46
%48 = getelementptr inbounds double, double* %26, i64 %41
store double %47, double* %48
%49 = getelementptr inbounds double, double* %18, i64 %33
%50 = load double, double* %49
%51 = getelementptr inbounds double, double* %28, i64 %41
store double %50, double* %51
%52 = add nuw nsw i64 %33, 1
%53 = icmp eq i64 %52, %31
br i1 %53, label %54, label %32
54: ; preds = %32, %8
%55 = tail call i32 @free(double* %15)
%56 = tail call i32 @free(double* %16)
%57 = tail call i32 @free(double* %17)
%58 = tail call i32 @free(double* %18)
%59 = tail call double* @malloc(i32 %24)
%60 = tail call double* @malloc(i32 %24)
%61 = tail call double* @malloc(i32 %24)
%62 = tail call double* @malloc(i32 %24)
%63 = tail call i32 @i_conv(double* %25, i32 %23, double* %59, i32 %23, double* %5, i32 %7)
%64 = tail call i32 @i_conv(double* %27, i32 %23, double* %60, i32 %23, double* %6, i32 %7)
br i1 %29, label %65, label %254
65: ; preds = %54
%66 = call i32 @llvm.smax.i32(i32 %23, i32 1)
%67 = zext i32 %66 to i64
%68 = icmp ult i32 %66, 4
br i1 %68, label %145, label %69
69: ; preds = %65
%70 = and i64 %67, 2147483644
%71 = add nsw i64 %70, -4
%72 = lshr exact i64 %71, 2
%73 = add nuw nsw i64 %72, 1
%74 = and i64 %73, 1
%75 = icmp eq i64 %71, 0
br i1 %75, label %121, label %76
76: ; preds = %69
%77 = and i64 %73, 9223372036854775806
br label %78
78: ; preds = %78, %76
%79 = phi i64 [ 0, %76 ], [ %118, %78 ]
%80 = phi i64 [ 0, %76 ], [ %119, %78 ]
%81 = getelementptr inbounds double, double* %59, i64 %79
%82 = bitcast double* %81 to <2 x double>*
%83 = load <2 x double>, <2 x double>* %82
%84 = getelementptr inbounds double, double* %81, i64 2
%85 = bitcast double* %84 to <2 x double>*
%86 = load <2 x double>, <2 x double>* %85
%87 = getelementptr inbounds double, double* %60, i64 %79
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = getelementptr inbounds double, double* %87, i64 2
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = fadd <2 x double> %83, %89
%94 = fadd <2 x double> %86, %92
%95 = getelementptr inbounds double, double* %61, i64 %79
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> %93, <2 x double>* %96
%97 = getelementptr inbounds double, double* %95, i64 2
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> %94, <2 x double>* %98
%99 = or i64 %79, 4
%100 = getelementptr inbounds double, double* %59, i64 %99
%101 = bitcast double* %100 to <2 x double>*
%102 = load <2 x double>, <2 x double>* %101
%103 = getelementptr inbounds double, double* %100, i64 2
%104 = bitcast double* %103 to <2 x double>*
%105 = load <2 x double>, <2 x double>* %104
%106 = getelementptr inbounds double, double* %60, i64 %99
%107 = bitcast double* %106 to <2 x double>*
%108 = load <2 x double>, <2 x double>* %107
%109 = getelementptr inbounds double, double* %106, i64 2
%110 = bitcast double* %109 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = fadd <2 x double> %102, %108
%113 = fadd <2 x double> %105, %111
%114 = getelementptr inbounds double, double* %61, i64 %99
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> %112, <2 x double>* %115
%116 = getelementptr inbounds double, double* %114, i64 2
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> %113, <2 x double>* %117
%118 = add nuw i64 %79, 8
%119 = add i64 %80, 2
%120 = icmp eq i64 %119, %77
br i1 %120, label %121, label %78
121: ; preds = %78, %69
%122 = phi i64 [ 0, %69 ], [ %118, %78 ]
%123 = icmp eq i64 %74, 0
br i1 %123, label %143, label %124
124: ; preds = %121
%125 = getelementptr inbounds double, double* %59, i64 %122
%126 = bitcast double* %125 to <2 x double>*
%127 = load <2 x double>, <2 x double>* %126
%128 = getelementptr inbounds double, double* %125, i64 2
%129 = bitcast double* %128 to <2 x double>*
%130 = load <2 x double>, <2 x double>* %129
%131 = getelementptr inbounds double, double* %60, i64 %122
%132 = bitcast double* %131 to <2 x double>*
%133 = load <2 x double>, <2 x double>* %132
%134 = getelementptr inbounds double, double* %131, i64 2
%135 = bitcast double* %134 to <2 x double>*
%136 = load <2 x double>, <2 x double>* %135
%137 = fadd <2 x double> %127, %133
%138 = fadd <2 x double> %130, %136
%139 = getelementptr inbounds double, double* %61, i64 %122
%140 = bitcast double* %139 to <2 x double>*
store <2 x double> %137, <2 x double>* %140
%141 = getelementptr inbounds double, double* %139, i64 2
%142 = bitcast double* %141 to <2 x double>*
store <2 x double> %138, <2 x double>* %142
br label %143
143: ; preds = %121, %124
%144 = icmp eq i64 %70, %67
br i1 %144, label %157, label %145
145: ; preds = %65, %143
%146 = phi i64 [ 0, %65 ], [ %70, %143 ]
br label %147
147: ; preds = %145, %147
%148 = phi i64 [ %155, %147 ], [ %146, %145 ]
%149 = getelementptr inbounds double, double* %59, i64 %148
%150 = load double, double* %149
%151 = getelementptr inbounds double, double* %60, i64 %148
%152 = load double, double* %151
%153 = fadd double %150, %152
%154 = getelementptr inbounds double, double* %61, i64 %148
store double %153, double* %154
%155 = add nuw nsw i64 %148, 1
%156 = icmp eq i64 %155, %67
br i1 %156, label %157, label %147
157: ; preds = %147, %143
%158 = tail call i32 @free(double* %25)
%159 = tail call i32 @free(double* %27)
%160 = tail call i32 @i_conv(double* %26, i32 %23, double* %59, i32 %23, double* %5, i32 %7)
%161 = tail call i32 @i_conv(double* %28, i32 %23, double* %60, i32 %23, double* %6, i32 %7)
br i1 %29, label %162, label %259
162: ; preds = %157
%163 = call i32 @llvm.smax.i32(i32 %23, i32 1)
%164 = zext i32 %163 to i64
%165 = icmp ult i32 %66, 4
br i1 %165, label %242, label %166
166: ; preds = %162
%167 = and i64 %67, 2147483644
%168 = add nsw i64 %167, -4
%169 = lshr exact i64 %168, 2
%170 = add nuw nsw i64 %169, 1
%171 = and i64 %170, 1
%172 = icmp eq i64 %168, 0
br i1 %172, label %218, label %173
173: ; preds = %166
%174 = and i64 %170, 9223372036854775806
br label %175
175: ; preds = %175, %173
%176 = phi i64 [ 0, %173 ], [ %215, %175 ]
%177 = phi i64 [ 0, %173 ], [ %216, %175 ]
%178 = getelementptr inbounds double, double* %59, i64 %176
%179 = bitcast double* %178 to <2 x double>*
%180 = load <2 x double>, <2 x double>* %179
%181 = getelementptr inbounds double, double* %178, i64 2
%182 = bitcast double* %181 to <2 x double>*
%183 = load <2 x double>, <2 x double>* %182
%184 = getelementptr inbounds double, double* %60, i64 %176
%185 = bitcast double* %184 to <2 x double>*
%186 = load <2 x double>, <2 x double>* %185
%187 = getelementptr inbounds double, double* %184, i64 2
%188 = bitcast double* %187 to <2 x double>*
%189 = load <2 x double>, <2 x double>* %188
%190 = fadd <2 x double> %180, %186
%191 = fadd <2 x double> %183, %189
%192 = getelementptr inbounds double, double* %62, i64 %176
%193 = bitcast double* %192 to <2 x double>*
store <2 x double> %190, <2 x double>* %193
%194 = getelementptr inbounds double, double* %192, i64 2
%195 = bitcast double* %194 to <2 x double>*
store <2 x double> %191, <2 x double>* %195
%196 = or i64 %176, 4
%197 = getelementptr inbounds double, double* %59, i64 %196
%198 = bitcast double* %197 to <2 x double>*
%199 = load <2 x double>, <2 x double>* %198
%200 = getelementptr inbounds double, double* %197, i64 2
%201 = bitcast double* %200 to <2 x double>*
%202 = load <2 x double>, <2 x double>* %201
%203 = getelementptr inbounds double, double* %60, i64 %196
%204 = bitcast double* %203 to <2 x double>*
%205 = load <2 x double>, <2 x double>* %204
%206 = getelementptr inbounds double, double* %203, i64 2
%207 = bitcast double* %206 to <2 x double>*
%208 = load <2 x double>, <2 x double>* %207
%209 = fadd <2 x double> %199, %205
%210 = fadd <2 x double> %202, %208
%211 = getelementptr inbounds double, double* %62, i64 %196
%212 = bitcast double* %211 to <2 x double>*
store <2 x double> %209, <2 x double>* %212
%213 = getelementptr inbounds double, double* %211, i64 2
%214 = bitcast double* %213 to <2 x double>*
store <2 x double> %210, <2 x double>* %214
%215 = add nuw i64 %176, 8
%216 = add i64 %177, 2
%217 = icmp eq i64 %216, %174
br i1 %217, label %218, label %175
218: ; preds = %175, %166
%219 = phi i64 [ 0, %166 ], [ %215, %175 ]
%220 = icmp eq i64 %171, 0
br i1 %220, label %240, label %221
221: ; preds = %218
%222 = getelementptr inbounds double, double* %59, i64 %219
%223 = bitcast double* %222 to <2 x double>*
%224 = load <2 x double>, <2 x double>* %223
%225 = getelementptr inbounds double, double* %222, i64 2
%226 = bitcast double* %225 to <2 x double>*
%227 = load <2 x double>, <2 x double>* %226
%228 = getelementptr inbounds double, double* %60, i64 %219
%229 = bitcast double* %228 to <2 x double>*
%230 = load <2 x double>, <2 x double>* %229
%231 = getelementptr inbounds double, double* %228, i64 2
%232 = bitcast double* %231 to <2 x double>*
%233 = load <2 x double>, <2 x double>* %232
%234 = fadd <2 x double> %224, %230
%235 = fadd <2 x double> %227, %233
%236 = getelementptr inbounds double, double* %62, i64 %219
%237 = bitcast double* %236 to <2 x double>*
store <2 x double> %234, <2 x double>* %237
%238 = getelementptr inbounds double, double* %236, i64 2
%239 = bitcast double* %238 to <2 x double>*
store <2 x double> %235, <2 x double>* %239
br label %240
240: ; preds = %218, %221
%241 = icmp eq i64 %167, %67
br i1 %241, label %259, label %242
242: ; preds = %162, %240
%243 = phi i64 [ 0, %162 ], [ %167, %240 ]
br label %244
244: ; preds = %242, %244
%245 = phi i64 [ %252, %244 ], [ %243, %242 ]
%246 = getelementptr inbounds double, double* %59, i64 %245
%247 = load double, double* %246
%248 = getelementptr inbounds double, double* %60, i64 %245
%249 = load double, double* %248
%250 = fadd double %247, %249
%251 = getelementptr inbounds double, double* %62, i64 %245
store double %250, double* %251
%252 = add nuw nsw i64 %245, 1
%253 = icmp eq i64 %252, %164
br i1 %253, label %259, label %244
254: ; preds = %54
%255 = tail call i32 @free(double* %25)
%256 = tail call i32 @free(double* %27)
%257 = tail call i32 @i_conv(double* %26, i32 %23, double* %59, i32 %23, double* %5, i32 %7)
%258 = tail call i32 @i_conv(double* %28, i32 %23, double* %60, i32 %23, double* %6, i32 %7)
br label %259
259: ; preds = %244, %240, %254, %157
%260 = tail call i32 @free(double* %26)
%261 = tail call i32 @free(double* %28)
%262 = tail call i32 @free(double* %59)
%263 = tail call i32 @free(double* %60)
%264 = xor i32 %7, -1
%265 = add i32 %264, %4
%266 = icmp slt i32 %265, %4
br i1 %266, label %267, label %330
267: ; preds = %259
%268 = sub i32 %7, %4
%269 = sext i32 %265 to i64
%270 = zext i32 %7 to i64
%271 = add nuw nsw i64 %270, 1
%272 = icmp slt i32 %7, 3
br i1 %272, label %307, label %273
273: ; preds = %267
%274 = and i64 %271, 8589934588
%275 = add nsw i64 %274, %269
br label %276
276: ; preds = %276, %273
%277 = phi i64 [ 0, %273 ], [ %303, %276 ]
%278 = add i64 %277, %269
%279 = getelementptr inbounds double, double* %61, 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* %62, i64 %278
%286 = bitcast double* %285 to <2 x double>*
%287 = load <2 x double>, <2 x double>* %286
%288 = getelementptr inbounds double, double* %285, i64 2
%289 = bitcast double* %288 to <2 x double>*
%290 = load <2 x double>, <2 x double>* %289
%291 = fadd <2 x double> %281, %287
%292 = fadd <2 x double> %284, %290
%293 = fmul <2 x double> %291, <double 5.000000e-01, double 5.000000e-01>
%294 = fmul <2 x double> %292, <double 5.000000e-01, double 5.000000e-01>
%295 = trunc i64 %278 to i32
%296 = add i32 %295, 1
%297 = add i32 %268, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %3, i64 %298
%300 = bitcast double* %299 to <2 x double>*
store <2 x double> %293, <2 x double>* %300
%301 = getelementptr inbounds double, double* %299, i64 2
%302 = bitcast double* %301 to <2 x double>*
store <2 x double> %294, <2 x double>* %302
%303 = add nuw i64 %277, 4
%304 = icmp eq i64 %303, %274
br i1 %304, label %305, label %276
305: ; preds = %276
%306 = icmp eq i64 %271, %274
br i1 %306, label %330, label %307
307: ; preds = %267, %305
%308 = phi i64 [ %269, %267 ], [ %275, %305 ]
%309 = trunc i64 %308 to i32
%310 = sub i32 %4, %309
%311 = xor i32 %309, -1
%312 = and i32 %310, 1
%313 = icmp eq i32 %312, 0
br i1 %313, label %326, label %314
314: ; preds = %307
%315 = getelementptr inbounds double, double* %61, i64 %308
%316 = load double, double* %315
%317 = getelementptr inbounds double, double* %62, i64 %308
%318 = load double, double* %317
%319 = fadd double %316, %318
%320 = fmul double %319, 5.000000e-01
%321 = add nsw i64 %308, 1
%322 = trunc i64 %321 to i32
%323 = add i32 %268, %322
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %3, i64 %324
store double %320, double* %325
br label %326
326: ; preds = %314, %307
%327 = phi i64 [ %308, %307 ], [ %321, %314 ]
%328 = sub i32 0, %4
%329 = icmp eq i32 %311, %328
br i1 %329, label %330, label %396
330: ; preds = %326, %396, %305, %259
%331 = icmp sgt i32 %265, 0
br i1 %331, label %332, label %446
332: ; preds = %330
%333 = zext i32 %265 to i64
%334 = icmp ult i32 %265, 4
br i1 %334, label %375, label %335
335: ; preds = %332
%336 = add nsw i64 %333, -1
%337 = add i32 %7, 1
%338 = trunc i64 %336 to i32
%339 = add i32 %337, %338
%340 = icmp slt i32 %339, %337
%341 = icmp ugt i64 %336, 4294967295
%342 = or i1 %340, %341
br i1 %342, label %375, label %343
343: ; preds = %335
%344 = and i64 %333, 4294967292
br label %345
345: ; preds = %345, %343
%346 = phi i64 [ 0, %343 ], [ %371, %345 ]
%347 = getelementptr inbounds double, double* %61, i64 %346
%348 = bitcast double* %347 to <2 x double>*
%349 = load <2 x double>, <2 x double>* %348
%350 = getelementptr inbounds double, double* %347, i64 2
%351 = bitcast double* %350 to <2 x double>*
%352 = load <2 x double>, <2 x double>* %351
%353 = getelementptr inbounds double, double* %62, i64 %346
%354 = bitcast double* %353 to <2 x double>*
%355 = load <2 x double>, <2 x double>* %354
%356 = getelementptr inbounds double, double* %353, i64 2
%357 = bitcast double* %356 to <2 x double>*
%358 = load <2 x double>, <2 x double>* %357
%359 = fadd <2 x double> %349, %355
%360 = fadd <2 x double> %352, %358
%361 = fmul <2 x double> %359, <double 5.000000e-01, double 5.000000e-01>
%362 = fmul <2 x double> %360, <double 5.000000e-01, double 5.000000e-01>
%363 = trunc i64 %346 to i32
%364 = or i32 %363, 1
%365 = add i32 %364, %7
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %3, i64 %366
%368 = bitcast double* %367 to <2 x double>*
store <2 x double> %361, <2 x double>* %368
%369 = getelementptr inbounds double, double* %367, i64 2
%370 = bitcast double* %369 to <2 x double>*
store <2 x double> %362, <2 x double>* %370
%371 = add nuw i64 %346, 4
%372 = icmp eq i64 %371, %344
br i1 %372, label %373, label %345
373: ; preds = %345
%374 = icmp eq i64 %344, %333
br i1 %374, label %446, label %375
375: ; preds = %335, %332, %373
%376 = phi i64 [ 0, %335 ], [ 0, %332 ], [ %344, %373 ]
%377 = xor i64 %376, -1
%378 = and i64 %333, 1
%379 = icmp eq i64 %378, 0
br i1 %379, label %392, label %380
380: ; preds = %375
%381 = getelementptr inbounds double, double* %61, i64 %376
%382 = load double, double* %381
%383 = getelementptr inbounds double, double* %62, i64 %376
%384 = load double, double* %383
%385 = fadd double %382, %384
%386 = fmul double %385, 5.000000e-01
%387 = or i64 %376, 1
%388 = trunc i64 %387 to i32
%389 = add i32 %388, %7
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %3, i64 %390
store double %386, double* %391
br label %392
392: ; preds = %380, %375
%393 = phi i64 [ %376, %375 ], [ %387, %380 ]
%394 = sub nsw i64 0, %333
%395 = icmp eq i64 %377, %394
br i1 %395, label %446, label %421
396: ; preds = %326, %396
%397 = phi i64 [ %415, %396 ], [ %327, %326 ]
%398 = getelementptr inbounds double, double* %61, i64 %397
%399 = load double, double* %398
%400 = getelementptr inbounds double, double* %62, i64 %397
%401 = load double, double* %400
%402 = fadd double %399, %401
%403 = fmul double %402, 5.000000e-01
%404 = add nsw i64 %397, 1
%405 = trunc i64 %404 to i32
%406 = add i32 %268, %405
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double, double* %3, i64 %407
store double %403, double* %408
%409 = getelementptr inbounds double, double* %61, i64 %404
%410 = load double, double* %409
%411 = getelementptr inbounds double, double* %62, i64 %404
%412 = load double, double* %411
%413 = fadd double %410, %412
%414 = fmul double %413, 5.000000e-01
%415 = add nsw i64 %397, 2
%416 = trunc i64 %415 to i32
%417 = add i32 %268, %416
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %3, i64 %418
store double %414, double* %419
%420 = icmp eq i32 %416, %4
br i1 %420, label %330, label %396
421: ; preds = %392, %421
%422 = phi i64 [ %440, %421 ], [ %393, %392 ]
%423 = getelementptr inbounds double, double* %61, i64 %422
%424 = load double, double* %423
%425 = getelementptr inbounds double, double* %62, i64 %422
%426 = load double, double* %425
%427 = fadd double %424, %426
%428 = fmul double %427, 5.000000e-01
%429 = add nuw nsw i64 %422, 1
%430 = trunc i64 %429 to i32
%431 = add i32 %430, %7
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds double, double* %3, i64 %432
store double %428, double* %433
%434 = getelementptr inbounds double, double* %61, i64 %429
%435 = load double, double* %434
%436 = getelementptr inbounds double, double* %62, i64 %429
%437 = load double, double* %436
%438 = fadd double %435, %437
%439 = fmul double %438, 5.000000e-01
%440 = add nuw nsw i64 %422, 2
%441 = trunc i64 %440 to i32
%442 = add i32 %441, %7
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds double, double* %3, i64 %443
store double %439, double* %444
%445 = icmp eq i64 %440, %333
br i1 %445, label %446, label %421
446: ; preds = %392, %421, %373, %330
%447 = tail call i32 @free(double* %61)
%448 = tail call i32 @free(double* %62)
ret void
}