#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*/ getfilter(void (*)(), void (*)(), void (*)(), void (*)(),
                             char, int);
int /*<<< orphan*/ memcpy(float *, float *, int);
int wavelet_decompose3(float *inspacevector, int Xlength, int Ylength,
                       int Zlength, char Filterlength, char Levels, char Skip,
                       float *covector, int *colength_ptr, char ifnotSilent) {
  int ifnotallskip = 1;
  float *vector = NULL;
  int Size;
  int mxlength, mylength, mzlength;
  int scale, xlength, ylength, zlength, maxscale;
  int LLLsubsize;
  int LLHsubsize;
  int LHLsubsize;
  int LHHsubsize;
  int HLHsubsize;
  int HHLsubsize;
  int HHHsubsize;
  int HLLsubsize;
  float *LLL = NULL, *LHH = NULL, *LLH = NULL, *LHL = NULL;
  float *HLL = NULL, *HHH = NULL, *HLH = NULL, *HHL = NULL;
  float *LLLv = NULL;
  int skipsize = 0;
  void (*bioD_3d)();
  void (*bioD_skip_3d)();
  void (*bioD_3d_char)();
  void (*bioD_skip_3d_char)();
  getfilter(&bioD_3d, &bioD_skip_3d, &bioD_3d_char, &bioD_skip_3d_char,
            Filterlength, 7);
  xlength = ((Xlength - 1) >> Skip) + 1;
  ylength = ((Ylength - 1) >> Skip) + 1;
  zlength = ((Zlength - 1) >> Skip) + 1;
  maxscale = Levels - 1;
  scale = 0;
  Size = Xlength * Ylength * Zlength;
  LLL = inspacevector;
  LLLsubsize = zlength * ylength * xlength;
  while ((scale <= maxscale) && (scale < Skip)) {
    if (scale == maxscale)
      LLL = covector;
    xlength = 1 + ((Xlength - 1) >> scale);
    ylength = 1 + ((Ylength - 1) >> scale);
    zlength = 1 + ((Zlength - 1) >> scale);
    if (!scale)
      bioD_skip_3d_char(inspacevector, HHH, HHL, HLH, HLL, LHH, LHL, LLH, LLL,
                        xlength, ylength, zlength, 0);
    else
      bioD_skip_3d(vector, HHH, HHL, HLH, HLL, LHH, LHL, LLH, LLL, xlength,
                   ylength, zlength, 0);
    vector = LLL;
    scale++;
  }
  skipsize = xlength * ylength * zlength;
  LLLv = covector;
  while (scale <= maxscale) {
    xlength = 1 + ((Xlength - 1) >> scale);
    ylength = 1 + ((Ylength - 1) >> scale);
    zlength = 1 + ((Zlength - 1) >> scale);
    mxlength = (xlength + 1) >> 1;
    mylength = (ylength + 1) >> 1;
    mzlength = (zlength + 1) / 2;
    vector = LLL;
    LLLsubsize = mzlength * mylength * mxlength;
    LLHsubsize = mzlength * mylength * (xlength - mxlength);
    LHLsubsize = mzlength * (ylength - mylength) * mxlength;
    LHHsubsize = mzlength * (ylength - mylength) * (xlength - mxlength);
    HLLsubsize = (zlength - mzlength) * mylength * mxlength;
    HLHsubsize = (zlength - mzlength) * mylength * (xlength - mxlength);
    HHLsubsize = (zlength - mzlength) * (ylength - mylength) * mxlength;
    HHHsubsize =
        (zlength - mzlength) * (ylength - mylength) * (xlength - mxlength);
    if (scale == maxscale)
      LLL = covector;
    LLH = covector + LLLsubsize;
    LHL = LLH + LLHsubsize;
    LHH = LHL + LHLsubsize;
    HLL = LHH + LHHsubsize;
    HLH = HLL + HLLsubsize;
    HHL = HLH + HLHsubsize;
    HHH = HHL + HHLsubsize;
    if ((!scale)) {
      bioD_3d_char(inspacevector, HHH, HHL, HLH, HLL, LHH, LHL, LLH, LLL,
                   xlength, ylength, zlength, ifnotallskip);
    } else {
      bioD_3d(vector, HHH, HHL, HLH, HLL, LHH, LHL, LLH, LLL, xlength, ylength,
              zlength, ifnotallskip);
    }
    scale++;
    vector = LLL;
  }
  if (LLL != LLLv)
    memcpy(LLLv, LLL, LLLsubsize * sizeof(float));
  *colength_ptr = skipsize;
  return 0;
}


x86 assembly (clang, -O0):
<wavelet_decompose3>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r8d,-0x118(%rbp)
mov    %ecx,%eax
mov    -0x118(%rbp),%ecx
mov    %eax,-0x114(%rbp)
mov    %edx,%eax
mov    -0x114(%rbp),%edx
mov    %eax,-0x110(%rbp)
mov    %esi,%eax
mov    -0x110(%rbp),%esi
mov    %eax,-0x10c(%rbp)
mov    %rdi,%r8
mov    -0x10c(%rbp),%edi
mov    %r9b,%al
mov    0x28(%rbp),%r9b
mov    0x20(%rbp),%r9
mov    0x18(%rbp),%r9
mov    0x10(%rbp),%r9b
mov    %r8,-0x30(%rbp)
mov    %edi,-0x34(%rbp)
mov    %esi,-0x38(%rbp)
mov    %edx,-0x3c(%rbp)
mov    %cl,-0x3d(%rbp)
mov    %al,-0x3e(%rbp)
movl   $0x1,-0x44(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0xa0(%rbp)
movq   $0x0,-0xa8(%rbp)
movq   $0x0,-0xb0(%rbp)
movq   $0x0,-0xb8(%rbp)
movq   $0x0,-0xc0(%rbp)
movq   $0x0,-0xc8(%rbp)
movq   $0x0,-0xd0(%rbp)
movq   $0x0,-0xd8(%rbp)
movq   $0x0,-0xe0(%rbp)
movl   $0x0,-0xe4(%rbp)
lea    -0xf0(%rbp),%rdi
lea    -0xf8(%rbp),%rsi
lea    -0x100(%rbp),%rdx
lea    -0x108(%rbp),%rcx
mov    $0x7,%r9d
movsbl -0x3d(%rbp),%r8d
call   1040 <getfilter@plt>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
movsbl 0x10(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
movsbl 0x10(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
movsbl 0x10(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
movsbl -0x3e(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x38(%rbp),%eax
imul   -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x70(%rbp),%eax
imul   -0x6c(%rbp),%eax
imul   -0x68(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x64(%rbp),%ecx
xor    %eax,%eax
cmp    -0x74(%rbp),%ecx
mov    %al,-0x119(%rbp)
jg     12d0 <wavelet_decompose3+0x1b0>
mov    -0x64(%rbp),%eax
movsbl 0x10(%rbp),%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x119(%rbp)
mov    -0x119(%rbp),%al
test   $0x1,%al
jne    12e3 <wavelet_decompose3+0x1c3>
jmp    1445 <wavelet_decompose3+0x325>
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jne    12fa <wavelet_decompose3+0x1da>
mov    0x18(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    -0x64(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    -0x64(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    -0x64(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x0,-0x64(%rbp)
jne    13b4 <wavelet_decompose3+0x294>
mov    -0x108(%rbp),%r10
mov    -0x30(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
mov    -0xd8(%rbp),%rdx
mov    -0xd0(%rbp),%rcx
mov    -0xc0(%rbp),%r8
mov    -0xa8(%rbp),%r9
mov    -0xb8(%rbp),%r12
mov    -0xb0(%rbp),%r15
mov    -0xa0(%rbp),%r14
mov    -0x68(%rbp),%ebx
mov    -0x6c(%rbp),%r11d
mov    -0x70(%rbp),%eax
xor    %r13d,%r13d
mov    %r12,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %eax,0x28(%rsp)
movl   $0x0,0x30(%rsp)
mov    $0x0,%al
call   *%r10
jmp    142c <wavelet_decompose3+0x30c>
mov    -0xf8(%rbp),%r10
mov    -0x50(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
mov    -0xd8(%rbp),%rdx
mov    -0xd0(%rbp),%rcx
mov    -0xc0(%rbp),%r8
mov    -0xa8(%rbp),%r9
mov    -0xb8(%rbp),%r12
mov    -0xb0(%rbp),%r15
mov    -0xa0(%rbp),%r14
mov    -0x68(%rbp),%ebx
mov    -0x6c(%rbp),%r11d
mov    -0x70(%rbp),%eax
xor    %r13d,%r13d
mov    %r12,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %eax,0x28(%rsp)
movl   $0x0,0x30(%rsp)
mov    $0x0,%al
call   *%r10
mov    -0xa0(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12aa <wavelet_decompose3+0x18a>
mov    -0x68(%rbp),%eax
imul   -0x6c(%rbp),%eax
imul   -0x70(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    0x18(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     176a <wavelet_decompose3+0x64a>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    -0x64(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    -0x64(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    -0x64(%rbp),%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x60(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x5c(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x5c(%rbp),%eax
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
imul   %ecx,%eax
imul   -0x58(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
imul   %ecx,%eax
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x70(%rbp),%eax
sub    -0x60(%rbp),%eax
imul   -0x5c(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x70(%rbp),%eax
sub    -0x60(%rbp),%eax
imul   -0x5c(%rbp),%eax
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x88(%rbp)
mov    -0x70(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
imul   %ecx,%eax
imul   -0x58(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x70(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
imul   %ecx,%eax
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jne    159e <wavelet_decompose3+0x47e>
mov    0x18(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x80(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x84(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
movslq -0x88(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
cmpl   $0x0,-0x64(%rbp)
jne    16db <wavelet_decompose3+0x5bb>
mov    -0x100(%rbp),%r10
mov    -0x30(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
mov    -0xd8(%rbp),%rdx
mov    -0xd0(%rbp),%rcx
mov    -0xc0(%rbp),%r8
mov    -0xa8(%rbp),%r9
mov    -0xb8(%rbp),%r13
mov    -0xb0(%rbp),%r12
mov    -0xa0(%rbp),%r15
mov    -0x68(%rbp),%r14d
mov    -0x6c(%rbp),%ebx
mov    -0x70(%rbp),%r11d
mov    -0x44(%rbp),%eax
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %eax,0x30(%rsp)
mov    $0x0,%al
call   *%r10
jmp    1751 <wavelet_decompose3+0x631>
mov    -0xf0(%rbp),%r10
mov    -0x50(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
mov    -0xd8(%rbp),%rdx
mov    -0xd0(%rbp),%rcx
mov    -0xc0(%rbp),%r8
mov    -0xa8(%rbp),%r9
mov    -0xb8(%rbp),%r13
mov    -0xb0(%rbp),%r12
mov    -0xa0(%rbp),%r15
mov    -0x68(%rbp),%r14d
mov    -0x6c(%rbp),%ebx
mov    -0x70(%rbp),%r11d
mov    -0x44(%rbp),%eax
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %eax,0x30(%rsp)
mov    $0x0,%al
call   *%r10
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    1461 <wavelet_decompose3+0x341>
mov    -0xa0(%rbp),%rax
cmp    -0xe0(%rbp),%rax
je     179b <wavelet_decompose3+0x67b>
mov    -0xe0(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
movslq -0x78(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0xe4(%rbp),%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
xor    %eax,%eax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<wavelet_decompose3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9d,%r12d
mov    %ecx,%ebp
mov    %edx,%ebx
mov    %esi,%r13d
mov    %rdi,%r15
mov    0xa0(%rsp),%r14b
lea    0x60(%rsp),%rdi
lea    0x58(%rsp),%rsi
lea    0x50(%rsp),%rdx
lea    0x48(%rsp),%rcx
mov    $0x7,%r9d
call   1040 <getfilter@plt>
mov    %rbp,%r11
lea    -0x1(%r13),%eax
mov    %eax,%edi
mov    %r14d,%ecx
sar    %cl,%edi
add    $0x1,%edi
mov    %rbx,0x30(%rsp)
lea    -0x1(%rbx),%esi
mov    %esi,%edx
sar    %cl,%edx
lea    -0x1(%rbp),%ebx
mov    %ebx,%ebp
mov    %r14d,%r10d
sar    %cl,%ebp
add    $0x1,%edx
add    $0x1,%ebp
xor    %r14d,%r14d
mov    %r12,0x20(%rsp)
test   %r12b,%r12b
mov    %r15,0x40(%rsp)
mov    %eax,0x1c(%rsp)
mov    %esi,0x18(%rsp)
jle    1339 <wavelet_decompose3+0x219>
mov    %r13,%r9
mov    %ebp,%r8d
mov    %edx,%ecx
mov    %edi,%r13d
mov    %r15,0x28(%rsp)
test   %r10b,%r10b
jle    136b <wavelet_decompose3+0x24b>
mov    %edx,0xc(%rsp)
mov    %edi,0x10(%rsp)
mov    %ebp,0x8(%rsp)
movsbl %r10b,%ebp
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
add    $0xffffffff,%ebp
cmp    %eax,%ebp
cmovae %eax,%ebp
test   %eax,%eax
mov    %r15,%rax
cmove  0xa8(%rsp),%rax
sub    $0x40,%rsp
mov    %r11d,0x28(%rsp)
mov    0x70(%rsp),%r13
mov    %r13d,0x20(%rsp)
mov    %r9,%r12
mov    %r12d,0x18(%rsp)
xorps  %xmm0,%xmm0
movups %xmm0,(%rsp)
mov    %rax,0x68(%rsp)
mov    %rax,0x10(%rsp)
movl   $0x0,0x30(%rsp)
mov    %r15,%rdi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
mov    %r11,%r15
call   *0x88(%rsp)
add    $0x40,%rsp
test   %ebp,%ebp
je     1348 <wavelet_decompose3+0x228>
mov    %rbp,%rax
mov    %rbp,%rcx
add    $0x1,%eax
mov    %rax,0x38(%rsp)
neg    %ecx
mov    %rcx,0x30(%rsp)
mov    $0x2,%ebp
sub    0x20(%rsp),%ebp
mov    $0x1,%r15d
mov    %ebx,0x14(%rsp)
mov    0x28(%rsp),%rbx
nopl   0x0(%rax)
mov    %rbx,%rdi
lea    (%r15,%rbp,1),%eax
cmp    $0x1,%eax
cmove  0xa8(%rsp),%rbx
mov    0x1c(%rsp),%r13d
mov    %r15d,%ecx
sar    %cl,%r13d
add    $0x1,%r13d
mov    0x18(%rsp),%r14d
sar    %cl,%r14d
add    $0x1,%r14d
mov    0x14(%rsp),%r12d
sar    %cl,%r12d
add    $0x1,%r12d
sub    $0x40,%rsp
xorps  %xmm0,%xmm0
movups %xmm0,(%rsp)
mov    %r12d,0x28(%rsp)
mov    %r14d,0x20(%rsp)
mov    %r13d,0x18(%rsp)
mov    %rbx,0x10(%rsp)
movl   $0x0,0x30(%rsp)
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
call   *0x98(%rsp)
add    $0x40,%rsp
mov    0x30(%rsp),%rax
add    %r15d,%eax
add    $0x1,%eax
mov    %r15d,%ecx
add    $0x1,%ecx
mov    %ecx,%r15d
cmp    $0x1,%eax
jne    1280 <wavelet_decompose3+0x160>
mov    %r12d,%r8d
mov    %rbx,0x28(%rsp)
mov    0x1c(%rsp),%eax
mov    0x18(%rsp),%esi
mov    0x14(%rsp),%ebx
mov    0x8(%rsp),%ebp
mov    %r14d,%ecx
mov    0x38(%rsp),%r14
jmp    1363 <wavelet_decompose3+0x243>
mov    %ebp,%r8d
mov    %edx,%ecx
mov    %edi,%r13d
mov    %r15,0x28(%rsp)
jmp    136b <wavelet_decompose3+0x24b>
mov    $0x1,%r14d
mov    %r15d,%r8d
mov    %r13d,%ecx
mov    %r12d,%r13d
mov    0x1c(%rsp),%eax
mov    0x18(%rsp),%esi
mov    0x8(%rsp),%ebp
mov    0x10(%rsp),%edi
mov    0xc(%rsp),%edx
mov    %ecx,0x38(%rsp)
mov    %r13d,0x10(%rsp)
cmp    0x20(%rsp),%r14d
mov    %r8d,0xc(%rsp)
jge    14de <wavelet_decompose3+0x3be>
mov    0x20(%rsp),%rcx
neg    %ecx
mov    %rcx,0x20(%rsp)
mov    0x28(%rsp),%r11
mov    %r11,%rdi
mov    %ebx,0x14(%rsp)
jmp    13e8 <wavelet_decompose3+0x2c8>
xchg   %ax,%ax
sub    $0x8,%rsp
mov    0x48(%rsp),%rdi
xor    %eax,%eax
push   $0x1
push   %r12
push   0x48(%rsp)
push   %r13
push   %rbx
push   %rbp
push   %r10
call   *0x90(%rsp)
add    $0x40,%rsp
add    $0x1,%r14d
mov    0x20(%rsp),%rax
mov    %rbx,%rdi
add    %r14d,%eax
mov    0x1c(%rsp),%eax
mov    0x18(%rsp),%esi
mov    %rbx,%r11
mov    0x14(%rsp),%ebx
je     14ed <wavelet_decompose3+0x3cd>
mov    %eax,%edx
mov    %r14d,%ecx
sar    %cl,%edx
mov    %esi,%eax
sar    %cl,%eax
lea    0x1(%rdx),%r9d
mov    %ebx,%esi
sar    %cl,%esi
lea    0x1(%rax),%ebx
lea    0x1(%rsi),%ebp
add    $0x2,%edx
sar    %edx
add    $0x2,%eax
sar    %eax
mov    %esi,%ecx
add    $0x2,%ecx
shr    $0x1f,%ecx
add    %esi,%ecx
add    $0x2,%ecx
sar    %ecx
mov    %rbx,0x30(%rsp)
mov    %ebx,%esi
sub    %eax,%esi
mov    %esi,%r8d
imul   %ecx,%r8d
mov    %rbp,%r12
mov    %ebp,%ebx
sub    %ecx,%ebx
imul   %eax,%ecx
mov    %ecx,%r10d
mov    %r9,%r13
mov    %r9d,%ebp
sub    %edx,%ebp
imul   %ebp,%ecx
mov    %r8d,%r9d
imul   %ebp,%r8d
imul   %ebx,%eax
mov    %eax,%r15d
imul   %ebp,%eax
mov    0xa8(%rsp),%rbp
imul   %edx,%r10d
imul   %edx,%r9d
imul   %edx,%r15d
imul   %edx,%esi
imul   %ebx,%esi
mov    0x20(%rsp),%rdx
add    %r14d,%edx
cmp    $0xffffffff,%edx
cmove  %rbp,%r11
mov    %r10d,0x8(%rsp)
movslq %r10d,%rdx
lea    0x0(%rbp,%rdx,4),%rbp
movslq %ecx,%rcx
lea    0x0(%rbp,%rcx,4),%r10
movslq %r9d,%rcx
lea    (%r10,%rcx,4),%r9
movslq %r8d,%rcx
lea    (%r9,%rcx,4),%r8
movslq %r15d,%rcx
lea    (%r8,%rcx,4),%rcx
cltq
lea    (%rcx,%rax,4),%rdx
movslq %esi,%rax
lea    (%rdx,%rax,4),%rsi
test   %r14d,%r14d
mov    %r11,%rbx
je     13a0 <wavelet_decompose3+0x280>
sub    $0x8,%rsp
xor    %eax,%eax
push   $0x1
push   %r12
push   0x48(%rsp)
push   %r13
push   %rbx
push   %rbp
push   %r10
call   *0xa0(%rsp)
jmp    13c0 <wavelet_decompose3+0x2a0>
imul   %edx,%ebp
imul   %edi,%ebp
mov    %ebp,0x8(%rsp)
mov    0x28(%rsp),%r11
mov    0xb0(%rsp),%rbx
cmp    0xa8(%rsp),%r11
je     1516 <wavelet_decompose3+0x3f6>
mov    0x8(%rsp),%edx
shl    $0x2,%edx
mov    0xa8(%rsp),%rdi
mov    %r11,%rsi
call   1030 <memcpy@plt>
mov    0x38(%rsp),%eax
imul   0xc(%rsp),%eax
imul   0x10(%rsp),%eax
mov    %eax,(%rbx)
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @wavelet_decompose3(float* %0, i32 %1, i32 %2, i32 %3, i8 signext %4, i8 signext %5, i8 signext %6, float* %7, i32* nocapture writeonly %8, i8 signext %9) {
%11 = alloca void (...)*
%12 = alloca void (...)*
%13 = alloca void (...)*
%14 = alloca void (...)*
%15 = bitcast void (...)** %11 to i8*
%16 = bitcast void (...)** %12 to i8*
%17 = bitcast void (...)** %13 to i8*
%18 = bitcast void (...)** %14 to i8*
%19 = bitcast void (...)** %11 to void (...)*
%20 = bitcast void (...)** %12 to void (...)*
%21 = bitcast void (...)** %13 to void (...)*
%22 = bitcast void (...)** %14 to void (...)*
%23 = call i32 @getfilter(void (...)* %19, void (...)* %20, void (...)* %21, void (...)* %22, i8 signext %4, i32 7)
%24 = add nsw i32 %1, -1
%25 = sext i8 %6 to i32
%26 = ashr i32 %24, %25
%27 = add nsw i32 %26, 1
%28 = add nsw i32 %2, -1
%29 = ashr i32 %28, %25
%30 = add nsw i32 %29, 1
%31 = add nsw i32 %3, -1
%32 = ashr i32 %31, %25
%33 = add nsw i32 %32, 1
%34 = sext i8 %5 to i32
%35 = add nsw i32 %34, -1
%36 = mul nsw i32 %33, %30
%37 = mul nsw i32 %36, %27
%38 = icmp sgt i8 %5, 0
%39 = icmp sgt i8 %6, 0
%40 = and i1 %38, %39
br i1 %40, label %41, label %51
41: ; preds = %10
%42 = bitcast void (...)** %12 to void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)**
%43 = add nsw i32 %25, -1
%44 = call i32 @llvm.umin.i32(i32 %43, i32 %35)
%45 = add nsw i32 %44, 1
%46 = icmp eq i32 %35, 0
%47 = select i1 %46, float* %7, float* %0
%48 = bitcast void (...)** %14 to void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)**
%49 = load void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)*, void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)** %48
%50 = icmp eq i32 %44, 0
br i1 %50, label %51, label %61
51: ; preds = %61, %41, %10
%52 = phi i32 [ %33, %10 ], [ %3, %41 ], [ %71, %61 ]
%53 = phi i32 [ %30, %10 ], [ %2, %41 ], [ %69, %61 ]
%54 = phi i32 [ %27, %10 ], [ %1, %41 ], [ %67, %61 ]
%55 = phi i32 [ 0, %10 ], [ 1, %41 ], [ %45, %61 ]
%56 = phi float* [ %0, %10 ], [ %47, %41 ], [ %65, %61 ]
%57 = icmp slt i32 %55, %34
br i1 %57, label %58, label %128
58: ; preds = %51
%59 = bitcast void (...)** %11 to void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)**
%60 = bitcast void (...)** %13 to void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)**
br label %75
61: ; preds = %41, %61
%62 = phi float* [ %65, %61 ], [ %47, %41 ]
%63 = phi i32 [ %73, %61 ], [ 1, %41 ]
%64 = icmp eq i32 %63, %35
%65 = select i1 %64, float* %7, float* %62
%66 = ashr i32 %24, %63
%67 = add nsw i32 %66, 1
%68 = ashr i32 %28, %63
%69 = add nsw i32 %68, 1
%70 = ashr i32 %31, %63
%71 = add nsw i32 %70, 1
%72 = load void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)*, void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)** %42
%73 = add nuw nsw i32 %63, 1
%74 = icmp eq i32 %63, %44
br i1 %74, label %51, label %61
75: ; preds = %58, %125
%76 = phi float* [ %56, %58 ], [ %105, %125 ]
%77 = phi i32 [ %55, %58 ], [ %126, %125 ]
%78 = ashr i32 %24, %77
%79 = add nsw i32 %78, 1
%80 = ashr i32 %28, %77
%81 = add nsw i32 %80, 1
%82 = ashr i32 %31, %77
%83 = add nsw i32 %82, 1
%84 = add nsw i32 %78, 2
%85 = ashr i32 %84, 1
%86 = add nsw i32 %80, 2
%87 = ashr i32 %86, 1
%88 = add nsw i32 %82, 2
%89 = sdiv i32 %88, 2
%90 = mul nsw i32 %89, %87
%91 = mul nsw i32 %90, %85
%92 = sub nsw i32 %79, %85
%93 = mul nsw i32 %90, %92
%94 = sub nsw i32 %81, %87
%95 = mul nsw i32 %94, %89
%96 = mul nsw i32 %95, %85
%97 = mul nsw i32 %95, %92
%98 = sub nsw i32 %83, %89
%99 = mul nsw i32 %98, %87
%100 = mul nsw i32 %99, %85
%101 = mul nsw i32 %99, %92
%102 = mul i32 %94, %85
%103 = mul i32 %102, %98
%104 = icmp eq i32 %77, %35
%105 = select i1 %104, float* %7, float* %76
%106 = sext i32 %91 to i64
%107 = getelementptr inbounds float, float* %7, i64 %106
%108 = sext i32 %93 to i64
%109 = getelementptr inbounds float, float* %107, i64 %108
%110 = sext i32 %96 to i64
%111 = getelementptr inbounds float, float* %109, i64 %110
%112 = sext i32 %97 to i64
%113 = getelementptr inbounds float, float* %111, i64 %112
%114 = sext i32 %100 to i64
%115 = getelementptr inbounds float, float* %113, i64 %114
%116 = sext i32 %101 to i64
%117 = getelementptr inbounds float, float* %115, i64 %116
%118 = sext i32 %103 to i64
%119 = getelementptr inbounds float, float* %117, i64 %118
%120 = icmp eq i32 %77, 0
br i1 %120, label %121, label %123
121: ; preds = %75
%122 = load void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)*, void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)** %60
br label %125
123: ; preds = %75
%124 = load void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)*, void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)** %59
br label %125
125: ; preds = %123, %121
%126 = add i32 %77, 1
%127 = icmp eq i32 %126, %34
br i1 %127, label %128, label %75
128: ; preds = %125, %51
%129 = phi i32 [ %37, %51 ], [ %91, %125 ]
%130 = phi float* [ %56, %51 ], [ %105, %125 ]
%131 = icmp eq float* %130, %7
br i1 %131, label %135, label %132
132: ; preds = %128
%133 = shl i32 %129, 2
%134 = call i32 @memcpy(float* %7, float* %130, i32 %133)
br label %135
135: ; preds = %132, %128
%136 = mul i32 %53, %52
%137 = mul i32 %136, %54
store i32 %137, i32* %8
ret i32 0
}