#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*/ getadjointfilter(void (*)(), void (*)(), void (*)(),
                                    void (*)(), char, int);
int /*<<< orphan*/ memcpy(float *, float *, int);
int wavelet_invadjoint3(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 (*adjbioR_3d)();
  void (*adjbioR_skip_3d)();
  void (*adjbioR_3d_char)();
  void (*adjbioR_skip_3d_char)();
  getadjointfilter(&adjbioR_3d, &adjbioR_skip_3d, &adjbioR_3d_char,
                   &adjbioR_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;
  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)
      adjbioR_skip_3d_char(inspacevector, HHH, HHL, HLH, HLL, LHH, LHL, LLH,
                           LLL, xlength, ylength, zlength, 0);
    else
      adjbioR_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;
    zlength = 1 + ((Zlength - 1) >> scale);
    if ((!scale)) {
      adjbioR_3d_char(inspacevector, HHH, HHL, HLH, HLL, LHH, LHL, LLH, LLL,
                      xlength, ylength, zlength, ifnotallskip);
    } else {
      adjbioR_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_invadjoint3>:
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
movsbl -0x3d(%rbp),%r8d
xor    %eax,%eax
sub    %r8d,%eax
mov    $0x7,%r9d
movsbl %al,%r8d
call   1030 <getadjointfilter@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    -0x64(%rbp),%ecx
xor    %eax,%eax
cmp    -0x74(%rbp),%ecx
mov    %al,-0x119(%rbp)
jg     12cb <wavelet_invadjoint3+0x1ab>
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    12de <wavelet_invadjoint3+0x1be>
jmp    1440 <wavelet_invadjoint3+0x320>
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jne    12f5 <wavelet_invadjoint3+0x1d5>
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    13af <wavelet_invadjoint3+0x28f>
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    1427 <wavelet_invadjoint3+0x307>
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    12a5 <wavelet_invadjoint3+0x185>
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     1776 <wavelet_invadjoint3+0x656>
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    1599 <wavelet_invadjoint3+0x479>
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)
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    16e7 <wavelet_invadjoint3+0x5c7>
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    175d <wavelet_invadjoint3+0x63d>
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    145c <wavelet_invadjoint3+0x33c>
mov    -0xa0(%rbp),%rax
cmp    -0xe0(%rbp),%rax
je     17a7 <wavelet_invadjoint3+0x687>
mov    -0xe0(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
movslq -0x78(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1040 <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_invadjoint3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9d,%r12d
mov    %ecx,%ebp
mov    %edx,%r13d
mov    %esi,%ebx
mov    %rdi,%r15
mov    0xa0(%rsp),%r14b
neg    %r8b
movsbl %r8b,%r8d
lea    0x60(%rsp),%rdi
lea    0x58(%rsp),%rsi
lea    0x50(%rsp),%rdx
lea    0x48(%rsp),%rcx
mov    $0x7,%r9d
call   1030 <getadjointfilter@plt>
mov    %r14d,%ecx
mov    %r13,%r10
mov    %rbx,%r8
mov    %r12,%r9
add    $0xffffffff,%ebx
mov    %ebx,%eax
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,0x14(%rsp)
lea    -0x1(%r13),%eax
mov    %eax,%edx
sar    %cl,%edx
lea    -0x1(%rbp),%esi
mov    %esi,%r13d
sar    %cl,%r13d
add    $0x1,%edx
add    $0x1,%r13d
test   %r9b,%r9b
mov    %r15,0x38(%rsp)
mov    %eax,0x10(%rsp)
mov    %esi,0xc(%rsp)
jle    1315 <wavelet_invadjoint3+0x1f5>
mov    %rbp,%r11
mov    $0x0,%r14d
mov    %r15,%r12
test   %cl,%cl
mov    %edx,%ebp
jle    131d <wavelet_invadjoint3+0x1fd>
movsbl %cl,%ebp
lea    -0x1(%r9),%eax
add    $0xffffffff,%ebp
cmp    %eax,%ebp
cmovae %eax,%ebp
test   %eax,%eax
mov    0x38(%rsp),%rdi
mov    %rdi,%r12
cmove  0xa8(%rsp),%r12
sub    $0x40,%rsp
mov    %r11,%r13
mov    %r13d,0x28(%rsp)
mov    %r10d,0x20(%rsp)
mov    %r8d,0x18(%rsp)
xorps  %xmm0,%xmm0
movups %xmm0,(%rsp)
mov    %r12,0x10(%rsp)
movl   $0x0,0x30(%rsp)
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    %r8,%r14
xor    %r8d,%r8d
mov    %r9,%r15
xor    %r9d,%r9d
xor    %eax,%eax
mov    %r10,0x58(%rsp)
call   *0x88(%rsp)
add    $0x40,%rsp
test   %ebp,%ebp
je     1486 <wavelet_invadjoint3+0x366>
mov    %rbp,%rax
lea    0x1(%rbp),%r14d
neg    %eax
mov    %rax,0x18(%rsp)
mov    $0x2,%eax
mov    %ebx,0x8(%rsp)
mov    %r15,0x28(%rsp)
sub    %r15d,%eax
mov    %rax,0x20(%rsp)
mov    $0x1,%r15d
nopl   0x0(%rax)
mov    %r12,%rdi
mov    0x20(%rsp),%rax
add    %r15d,%eax
cmp    $0x1,%eax
cmove  0xa8(%rsp),%r12
mov    0x8(%rsp),%ebx
mov    %r15d,%ecx
sar    %cl,%ebx
add    $0x1,%ebx
mov    0x10(%rsp),%ebp
sar    %cl,%ebp
add    $0x1,%ebp
mov    0xc(%rsp),%r13d
sar    %cl,%r13d
add    $0x1,%r13d
sub    $0x40,%rsp
xorps  %xmm0,%xmm0
movups %xmm0,(%rsp)
mov    %r13d,0x28(%rsp)
mov    %ebp,0x20(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r12,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    0x18(%rsp),%rax
add    %r15d,%eax
add    $0x1,%eax
mov    %r15d,%ecx
add    $0x1,%ecx
mov    %ecx,%r15d
cmp    $0x1,%eax
jne    1270 <wavelet_invadjoint3+0x150>
mov    %ebx,0x14(%rsp)
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%ebx
jmp    149d <wavelet_invadjoint3+0x37d>
xor    %r14d,%r14d
mov    %r15,%r12
mov    %edx,%ebp
cmp    %r9d,%r14d
jge    14ae <wavelet_invadjoint3+0x38e>
mov    %ebp,0x30(%rsp)
neg    %r9d
mov    %r12,%r15
mov    %r9,0x28(%rsp)
mov    %ebx,0x8(%rsp)
jmp    1389 <wavelet_invadjoint3+0x269>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rdi
xor    %eax,%eax
push   $0x1
push   0x50(%rsp)
push   0x38(%rsp)
push   0x38(%rsp)
push   %r15
push   %r11
push   %rbx
call   *0x90(%rsp)
add    $0x40,%rsp
add    $0x1,%r14d
mov    0x28(%rsp),%r9
mov    %r9d,%eax
mov    %r15,%r12
add    %r14d,%eax
mov    0x8(%rsp),%ebx
mov    0x10(%rsp),%eax
mov    0xc(%rsp),%esi
je     1476 <wavelet_invadjoint3+0x356>
mov    %ebx,%edx
mov    %r14d,%ecx
sar    %cl,%edx
sar    %cl,%eax
lea    0x1(%rdx),%ebx
sar    %cl,%esi
lea    0x1(%rax),%edi
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    %rdi,0x20(%rsp)
mov    %edi,%esi
sub    %eax,%esi
mov    %esi,%edi
imul   %ecx,%edi
mov    %rbp,0x40(%rsp)
sub    %ecx,%ebp
imul   %eax,%ecx
mov    %ecx,%r11d
mov    %rbx,0x18(%rsp)
sub    %edx,%ebx
imul   %ebx,%ecx
mov    %edi,%r8d
imul   %ebx,%edi
imul   %ebp,%eax
mov    %eax,%r10d
imul   %ebx,%eax
imul   %edx,%r11d
imul   %edx,%r8d
imul   %edx,%r10d
imul   %edx,%esi
imul   %ebp,%esi
lea    (%r9,%r14,1),%edx
cmp    $0xffffffff,%edx
mov    0xa8(%rsp),%rbp
cmove  %rbp,%r15
mov    %r11d,0x34(%rsp)
movslq %r11d,%rdx
lea    0x0(%rbp,%rdx,4),%r11
movslq %ecx,%rcx
lea    (%r11,%rcx,4),%rbx
movslq %r8d,%rcx
lea    (%rbx,%rcx,4),%r9
movslq %edi,%rcx
lea    (%r9,%rcx,4),%r8
movslq %r10d,%rcx
lea    (%r8,%rcx,4),%rcx
cltq
lea    (%rcx,%rax,4),%rdx
movslq %esi,%rax
lea    (%rdx,%rax,4),%rsi
sub    $0x8,%rsp
test   %r14d,%r14d
je     1340 <wavelet_invadjoint3+0x220>
mov    %r12,%rdi
xor    %eax,%eax
push   $0x1
push   0x50(%rsp)
push   0x38(%rsp)
push   0x38(%rsp)
push   %r15
push   %r11
push   %rbx
call   *0xa0(%rsp)
jmp    1361 <wavelet_invadjoint3+0x241>
mov    0x34(%rsp),%edx
shl    $0x2,%edx
mov    %r15,%rsi
mov    0x30(%rsp),%ebp
jmp    14b3 <wavelet_invadjoint3+0x393>
mov    %r14,%rax
mov    $0x1,%r14d
mov    0x18(%rsp),%rcx
mov    %ecx,%ebp
mov    %eax,0x14(%rsp)
mov    %r15,%r9
mov    0x10(%rsp),%eax
mov    0xc(%rsp),%esi
cmp    %r9d,%r14d
jl     1326 <wavelet_invadjoint3+0x206>
mov    %r12,%rsi
xor    %edx,%edx
mov    0xb0(%rsp),%r14
mov    0xa8(%rsp),%rdi
cmp    %rdi,%rsi
mov    0x14(%rsp),%ebx
je     14d1 <wavelet_invadjoint3+0x3b1>
call   1040 <memcpy@plt>
imul   %r13d,%ebp
imul   %ebx,%ebp
mov    %ebp,(%r14)
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_invadjoint3(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 = sext i8 %58 to i32
%60 = sub nsw i32 0, %59
%61 = trunc i32 %60 to i8
%62 = call i32 @getadjointfilter(void (...)* %54, void (...)* %55, void (...)* %56, void (...)* %57, i8 signext %61, i32 7)
%63 = load i32, i32* %12
%64 = sub nsw i32 %63, 1
%65 = load i8, i8* %17
%66 = sext i8 %65 to i32
%67 = ashr i32 %64, %66
%68 = add nsw i32 %67, 1
store i32 %68, i32* %28
%69 = load i32, i32* %13
%70 = sub nsw i32 %69, 1
%71 = load i8, i8* %17
%72 = sext i8 %71 to i32
%73 = ashr i32 %70, %72
%74 = add nsw i32 %73, 1
store i32 %74, i32* %29
%75 = load i32, i32* %14
%76 = sub nsw i32 %75, 1
%77 = load i8, i8* %17
%78 = sext i8 %77 to i32
%79 = ashr i32 %76, %78
%80 = add nsw i32 %79, 1
store i32 %80, i32* %30
%81 = load i8, i8* %16
%82 = sext i8 %81 to i32
%83 = sub nsw i32 %82, 1
store i32 %83, i32* %31
store i32 0, i32* %27
%84 = load i32, i32* %12
%85 = load i32, i32* %13
%86 = mul nsw i32 %84, %85
%87 = load i32, i32* %14
%88 = mul nsw i32 %86, %87
store i32 %88, i32* %23
%89 = load float*, float** %11
store float* %89, float** %40
br label %90
90: ; preds = %155, %10
%91 = load i32, i32* %27
%92 = load i32, i32* %31
%93 = icmp sle i32 %91, %92
br i1 %93, label %94, label %99
94: ; preds = %90
%95 = load i32, i32* %27
%96 = load i8, i8* %17
%97 = sext i8 %96 to i32
%98 = icmp slt i32 %95, %97
br label %99
99: ; preds = %94, %90
%100 = phi i1 [ false, %90 ], [ %98, %94 ]
br i1 %100, label %101, label %159
101: ; preds = %99
%102 = load i32, i32* %27
%103 = load i32, i32* %31
%104 = icmp eq i32 %102, %103
br i1 %104, label %105, label %107
105: ; preds = %101
%106 = load float*, float** %18
store float* %106, float** %40
br label %107
107: ; preds = %105, %101
%108 = load i32, i32* %12
%109 = sub nsw i32 %108, 1
%110 = load i32, i32* %27
%111 = ashr i32 %109, %110
%112 = add nsw i32 1, %111
store i32 %112, i32* %28
%113 = load i32, i32* %13
%114 = sub nsw i32 %113, 1
%115 = load i32, i32* %27
%116 = ashr i32 %114, %115
%117 = add nsw i32 1, %116
store i32 %117, i32* %29
%118 = load i32, i32* %14
%119 = sub nsw i32 %118, 1
%120 = load i32, i32* %27
%121 = ashr i32 %119, %120
%122 = add nsw i32 1, %121
store i32 %122, i32* %30
%123 = load i32, i32* %27
%124 = icmp ne i32 %123, 0
br i1 %124, label %140, label %125
125: ; preds = %107
%126 = load void (...)*, void (...)** %53
%127 = load float*, float** %11
%128 = load float*, float** %45
%129 = load float*, float** %47
%130 = load float*, float** %46
%131 = load float*, float** %44
%132 = load float*, float** %41
%133 = load float*, float** %43
%134 = load float*, float** %42
%135 = load float*, float** %40
%136 = load i32, i32* %28
%137 = load i32, i32* %29
%138 = load i32, i32* %30
%139 = bitcast void (...)* %126 to void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)*
br label %155
140: ; preds = %107
%141 = load void (...)*, void (...)** %51
%142 = load float*, float** %22
%143 = load float*, float** %45
%144 = load float*, float** %47
%145 = load float*, float** %46
%146 = load float*, float** %44
%147 = load float*, float** %41
%148 = load float*, float** %43
%149 = load float*, float** %42
%150 = load float*, float** %40
%151 = load i32, i32* %28
%152 = load i32, i32* %29
%153 = load i32, i32* %30
%154 = bitcast void (...)* %141 to void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)*
br label %155
155: ; preds = %140, %125
%156 = load float*, float** %40
store float* %156, float** %22
%157 = load i32, i32* %27
%158 = add nsw i32 %157, 1
store i32 %158, i32* %27
br label %90
159: ; preds = %99
%160 = load i32, i32* %28
%161 = load i32, i32* %29
%162 = mul nsw i32 %160, %161
%163 = load i32, i32* %30
%164 = mul nsw i32 %162, %163
store i32 %164, i32* %49
%165 = load float*, float** %18
store float* %165, float** %48
br label %166
166: ; preds = %333, %159
%167 = load i32, i32* %27
%168 = load i32, i32* %31
%169 = icmp sle i32 %167, %168
br i1 %169, label %170, label %337
170: ; preds = %166
%171 = load i32, i32* %12
%172 = sub nsw i32 %171, 1
%173 = load i32, i32* %27
%174 = ashr i32 %172, %173
%175 = add nsw i32 1, %174
store i32 %175, i32* %28
%176 = load i32, i32* %13
%177 = sub nsw i32 %176, 1
%178 = load i32, i32* %27
%179 = ashr i32 %177, %178
%180 = add nsw i32 1, %179
store i32 %180, i32* %29
%181 = load i32, i32* %14
%182 = sub nsw i32 %181, 1
%183 = load i32, i32* %27
%184 = ashr i32 %182, %183
%185 = add nsw i32 1, %184
store i32 %185, i32* %30
%186 = load i32, i32* %28
%187 = add nsw i32 %186, 1
%188 = ashr i32 %187, 1
store i32 %188, i32* %24
%189 = load i32, i32* %29
%190 = add nsw i32 %189, 1
%191 = ashr i32 %190, 1
store i32 %191, i32* %25
%192 = load i32, i32* %30
%193 = add nsw i32 %192, 1
%194 = sdiv i32 %193, 2
store i32 %194, i32* %26
%195 = load float*, float** %40
store float* %195, float** %22
%196 = load i32, i32* %26
%197 = load i32, i32* %25
%198 = mul nsw i32 %196, %197
%199 = load i32, i32* %24
%200 = mul nsw i32 %198, %199
store i32 %200, i32* %32
%201 = load i32, i32* %26
%202 = load i32, i32* %25
%203 = mul nsw i32 %201, %202
%204 = load i32, i32* %28
%205 = load i32, i32* %24
%206 = sub nsw i32 %204, %205
%207 = mul nsw i32 %203, %206
store i32 %207, i32* %33
%208 = load i32, i32* %26
%209 = load i32, i32* %29
%210 = load i32, i32* %25
%211 = sub nsw i32 %209, %210
%212 = mul nsw i32 %208, %211
%213 = load i32, i32* %24
%214 = mul nsw i32 %212, %213
store i32 %214, i32* %34
%215 = load i32, i32* %26
%216 = load i32, i32* %29
%217 = load i32, i32* %25
%218 = sub nsw i32 %216, %217
%219 = mul nsw i32 %215, %218
%220 = load i32, i32* %28
%221 = load i32, i32* %24
%222 = sub nsw i32 %220, %221
%223 = mul nsw i32 %219, %222
store i32 %223, i32* %35
%224 = load i32, i32* %30
%225 = load i32, i32* %26
%226 = sub nsw i32 %224, %225
%227 = load i32, i32* %25
%228 = mul nsw i32 %226, %227
%229 = load i32, i32* %24
%230 = mul nsw i32 %228, %229
store i32 %230, i32* %39
%231 = load i32, i32* %30
%232 = load i32, i32* %26
%233 = sub nsw i32 %231, %232
%234 = load i32, i32* %25
%235 = mul nsw i32 %233, %234
%236 = load i32, i32* %28
%237 = load i32, i32* %24
%238 = sub nsw i32 %236, %237
%239 = mul nsw i32 %235, %238
store i32 %239, i32* %36
%240 = load i32, i32* %30
%241 = load i32, i32* %26
%242 = sub nsw i32 %240, %241
%243 = load i32, i32* %29
%244 = load i32, i32* %25
%245 = sub nsw i32 %243, %244
%246 = mul nsw i32 %242, %245
%247 = load i32, i32* %24
%248 = mul nsw i32 %246, %247
store i32 %248, i32* %37
%249 = load i32, i32* %30
%250 = load i32, i32* %26
%251 = sub nsw i32 %249, %250
%252 = load i32, i32* %29
%253 = load i32, i32* %25
%254 = sub nsw i32 %252, %253
%255 = mul nsw i32 %251, %254
%256 = load i32, i32* %28
%257 = load i32, i32* %24
%258 = sub nsw i32 %256, %257
%259 = mul nsw i32 %255, %258
store i32 %259, i32* %38
%260 = load i32, i32* %27
%261 = load i32, i32* %31
%262 = icmp eq i32 %260, %261
br i1 %262, label %263, label %265
263: ; preds = %170
%264 = load float*, float** %18
store float* %264, float** %40
br label %265
265: ; preds = %263, %170
%266 = load float*, float** %18
%267 = load i32, i32* %32
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds float, float* %266, i64 %268
store float* %269, float** %42
%270 = load float*, float** %42
%271 = load i32, i32* %33
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds float, float* %270, i64 %272
store float* %273, float** %43
%274 = load float*, float** %43
%275 = load i32, i32* %34
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds float, float* %274, i64 %276
store float* %277, float** %41
%278 = load float*, float** %41
%279 = load i32, i32* %35
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float, float* %278, i64 %280
store float* %281, float** %44
%282 = load float*, float** %44
%283 = load i32, i32* %39
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds float, float* %282, i64 %284
store float* %285, float** %46
%286 = load float*, float** %46
%287 = load i32, i32* %36
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %286, i64 %288
store float* %289, float** %47
%290 = load float*, float** %47
%291 = load i32, i32* %37
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds float, float* %290, i64 %292
store float* %293, float** %45
%294 = load i32, i32* %14
%295 = sub nsw i32 %294, 1
%296 = load i32, i32* %27
%297 = ashr i32 %295, %296
%298 = add nsw i32 1, %297
store i32 %298, i32* %30
%299 = load i32, i32* %27
%300 = icmp ne i32 %299, 0
br i1 %300, label %317, label %301
301: ; preds = %265
%302 = load void (...)*, void (...)** %52
%303 = load float*, float** %11
%304 = load float*, float** %45
%305 = load float*, float** %47
%306 = load float*, float** %46
%307 = load float*, float** %44
%308 = load float*, float** %41
%309 = load float*, float** %43
%310 = load float*, float** %42
%311 = load float*, float** %40
%312 = load i32, i32* %28
%313 = load i32, i32* %29
%314 = load i32, i32* %30
%315 = load i32, i32* %21
%316 = bitcast void (...)* %302 to void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)*
br label %333
317: ; preds = %265
%318 = load void (...)*, void (...)** %50
%319 = load float*, float** %22
%320 = load float*, float** %45
%321 = load float*, float** %47
%322 = load float*, float** %46
%323 = load float*, float** %44
%324 = load float*, float** %41
%325 = load float*, float** %43
%326 = load float*, float** %42
%327 = load float*, float** %40
%328 = load i32, i32* %28
%329 = load i32, i32* %29
%330 = load i32, i32* %30
%331 = load i32, i32* %21
%332 = bitcast void (...)* %318 to void (float*, float*, float*, float*, float*, float*, float*, float*, float*, i32, i32, i32, i32, ...)*
br label %333
333: ; preds = %317, %301
%334 = load i32, i32* %27
%335 = add nsw i32 %334, 1
store i32 %335, i32* %27
%336 = load float*, float** %40
store float* %336, float** %22
br label %166
337: ; preds = %166
%338 = load float*, float** %40
%339 = load float*, float** %48
%340 = icmp ne float* %338, %339
br i1 %340, label %341, label %349
341: ; preds = %337
%342 = load float*, float** %48
%343 = load float*, float** %40
%344 = load i32, i32* %32
%345 = sext i32 %344 to i64
%346 = mul i64 %345, 4
%347 = trunc i64 %346 to i32
%348 = call i32 @memcpy(float* %342, float* %343, i32 %347)
br label %349
349: ; preds = %341, %337
%350 = load i32, i32* %49
%351 = load i32*, i32** %19
store i32 %350, i32* %351
ret i32 0
}

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