#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*/ free_vector(float *, int, unsigned long);
void stub1(float *, unsigned long, int);
void stub2(float *, unsigned long, int);
float *vector(int, unsigned long);
void wtn(float a[], unsigned long nn[], int ndim, int isign,
         void (*wtstep)(float[], unsigned long, int)) {
  unsigned long i1, i2, i3, k, n, nnew, nprev = 1, nt, ntot = 1;
  int idim;
  float *wksp;
  for (idim = 1; idim <= ndim; idim++)
    ntot *= nn[idim];
  wksp = vector(1, ntot);
  for (idim = 1; idim <= ndim; idim++) {
    n = nn[idim];
    nnew = n * nprev;
    if (n > 4) {
      for (i2 = 0; i2 < ntot; i2 += nnew) {
        for (i1 = 1; i1 <= nprev; i1++) {
          for (i3 = i1 + i2, k = 1; k <= n; k++, i3 += nprev)
            wksp[k] = a[i3];
          if (isign >= 0) {
            for (nt = n; nt >= 4; nt >>= 1)
              (*wtstep)(wksp, nt, isign);
          } else {
            for (nt = 4; nt <= n; nt <<= 1)
              (*wtstep)(wksp, nt, isign);
          }
          for (i3 = i1 + i2, k = 1; k <= n; k++, i3 += nprev)
            a[i3] = wksp[k];
        }
      }
    }
    nprev = nnew;
  }
  free_vector(wksp, 1, ntot);
}


x86 assembly (clang, -O0):
<wtn>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movq   $0x1,-0x58(%rbp)
movq   $0x1,-0x68(%rbp)
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1183 <wtn+0x63>
mov    -0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
imul   -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1154 <wtn+0x34>
mov    -0x68(%rbp),%rsi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x78(%rbp)
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1376 <wtn+0x256>
mov    -0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
imul   -0x58(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x4,-0x48(%rbp)
jbe    1360 <wtn+0x240>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x68(%rbp),%rax
jae    135b <wtn+0x23b>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x58(%rbp),%rax
ja     1345 <wtn+0x225>
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
ja     1255 <wtn+0x135>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x58(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1210 <wtn+0xf0>
cmpl   $0x0,-0x18(%rbp)
jl     1299 <wtn+0x179>
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x4,-0x60(%rbp)
jb     1294 <wtn+0x174>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%edx
call   *%rax
mov    -0x60(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1267 <wtn+0x147>
jmp    12d6 <wtn+0x1b6>
movq   $0x4,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x48(%rbp),%rax
ja     12d1 <wtn+0x1b1>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%edx
call   *%rax
mov    -0x60(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    12a1 <wtn+0x181>
jmp    12d6 <wtn+0x1b6>
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
ja     132f <wtn+0x20f>
mov    -0x78(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x58(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    12ea <wtn+0x1ca>
jmp    1334 <wtn+0x214>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11ee <wtn+0xce>
jmp    134a <wtn+0x22a>
mov    -0x50(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    11d8 <wtn+0xb8>
jmp    1360 <wtn+0x240>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    119c <wtn+0x7c>
mov    -0x78(%rbp),%rdi
mov    -0x68(%rbp),%rdx
mov    $0x1,%esi
call   1030 <free_vector@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<wtn>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
test   %edx,%edx
jle    115b <wtn+0x3b>
mov    %r8,%r15
mov    %edx,%r12d
mov    %rsi,%rbx
mov    %edx,%edx
lea    -0x1(%rdx),%rsi
mov    %edx,%eax
and    $0x7,%eax
cmp    $0x7,%rsi
jae    1177 <wtn+0x57>
mov    $0x1,%esi
mov    $0x1,%ebp
jmp    11cd <wtn+0xad>
mov    $0x1,%ebp
mov    $0x1,%esi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,%r14
jmp    18cf <wtn+0x7af>
and    $0xfffffff8,%edx
mov    $0x1,%ebp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
imul   0x8(%rbx,%rsi,8),%rbp
imul   0x10(%rbx,%rsi,8),%rbp
imul   0x18(%rbx,%rsi,8),%rbp
imul   0x20(%rbx,%rsi,8),%rbp
imul   0x28(%rbx,%rsi,8),%rbp
imul   0x30(%rbx,%rsi,8),%rbp
imul   0x38(%rbx,%rsi,8),%rbp
imul   0x40(%rbx,%rsi,8),%rbp
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1190 <wtn+0x70>
add    $0x1,%rsi
mov    %rdi,0x20(%rsp)
mov    %ecx,0x1c(%rsp)
test   %rax,%rax
je     11fe <wtn+0xde>
lea    (%rbx,%rsi,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
imul   (%rcx,%rdx,8),%rbp
add    $0x1,%rdx
cmp    %rdx,%rax
jne    11f0 <wtn+0xd0>
mov    $0x1,%edi
mov    %rbp,%rsi
call   1040 <vector@plt>
mov    %rax,%r14
test   %r12d,%r12d
jle    18cf <wtn+0x7af>
mov    %r15,0xc0(%rsp)
add    $0x1,%r12d
lea    0x4(%r14),%rax
mov    %rax,0x38(%rsp)
mov    0x20(%rsp),%r10
lea    0x14(%r10),%rax
mov    %rax,0xd8(%rsp)
mov    %r14,%rax
add    $0xc,%rax
mov    %rax,0xa0(%rsp)
mov    $0x1,%eax
mov    $0x1,%ecx
mov    %rcx,0x30(%rsp)
mov    0x1c(%rsp),%edx
mov    %r12,0xe8(%rsp)
mov    %rbx,0xe0(%rsp)
mov    %rbp,0xf8(%rsp)
jmp    12a5 <wtn+0x185>
nopl   0x0(%rax)
mov    0xf0(%rsp),%rax
add    $0x1,%rax
mov    0xe8(%rsp),%r12
cmp    %r12,%rax
mov    0xe0(%rsp),%rbx
je     18cf <wtn+0x7af>
mov    0x30(%rsp),%r12
mov    %rax,0xf0(%rsp)
mov    (%rbx,%rax,8),%rcx
mov    %rcx,%rax
imul   %r12,%rax
mov    %rax,0x30(%rsp)
mov    %rcx,0x10(%rsp)
cmp    $0x5,%rcx
jb     1280 <wtn+0x160>
test   %rbp,%rbp
je     1280 <wtn+0x160>
mov    0x10(%rsp),%rsi
lea    0x1(%rsi),%rax
mov    %rax,0x50(%rsp)
mov    0x38(%rsp),%rax
lea    (%rax,%rsi,4),%rax
mov    %rax,0xa8(%rsp)
lea    -0x8(%rsi),%rax
mov    %rax,0x98(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
cmp    $0x8,%rsi
setae  %al
cmp    $0x1,%r12
sete   %r9b
and    %al,%r9b
mov    %rsi,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,%rdi
imul   %r12,%rdi
mov    %rdi,0x80(%rsp)
mov    %rax,0x88(%rsp)
add    $0x1,%rax
mov    %rax,0x78(%rsp)
mov    %rcx,%rax
mov    %rcx,0x90(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x70(%rsp)
lea    0x0(,%r12,8),%rax
mov    %rax,0xb8(%rsp)
mov    %r12,%rax
shl    $0x5,%rax
mov    0xd8(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x68(%rsp)
imul   %r12,%rsi
shl    $0x2,%rsi
mov    %rsi,0x100(%rsp)
mov    %r12,%r11
shl    $0x6,%r11
mov    %r12,%r15
shl    $0x4,%r15
lea    0x0(,%r12,4),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0xb0(%rsp)
mov    %rcx,0x60(%rsp)
xor    %eax,%eax
mov    %rax,0x58(%rsp)
xor    %eax,%eax
mov    %rax,0x48(%rsp)
mov    %r9b,0xf(%rsp)
mov    %r11,0x40(%rsp)
mov    %r15,0x28(%rsp)
jmp    141b <wtn+0x2fb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x48(%rsp),%rcx
add    0x30(%rsp),%rcx
addq   $0x1,0x58(%rsp)
mov    0x100(%rsp),%rax
add    %rax,0x68(%rsp)
add    %rax,0x60(%rsp)
mov    0xf8(%rsp),%rbp
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
cmp    %rbp,%rcx
jae    1280 <wtn+0x160>
test   %r12,%r12
je     13e0 <wtn+0x2c0>
mov    0x10(%rsp),%rcx
imul   0x58(%rsp),%rcx
mov    0x50(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x108(%rsp)
add    $0x1,%rcx
mov    %rcx,0x110(%rsp)
mov    $0x1,%ecx
mov    0x60(%rsp),%rdi
mov    0x68(%rsp),%rbp
xor    %esi,%esi
jmp    1499 <wtn+0x379>
nopw   0x0(%rax,%rax,1)
mov    0x130(%rsp),%rcx
add    $0x1,%rcx
mov    0x128(%rsp),%rsi
add    $0x1,%rsi
mov    0xc8(%rsp),%rbp
add    $0x4,%rbp
mov    0xd0(%rsp),%rdi
add    $0x4,%rdi
cmp    %r12,%rcx
ja     13e0 <wtn+0x2c0>
mov    0x110(%rsp),%rax
add    %rsi,%rax
lea    (%r10,%rax,4),%rbx
mov    0x108(%rsp),%rax
mov    %rsi,0x128(%rsp)
add    %rsi,%rax
lea    (%r10,%rax,4),%rsi
mov    0x48(%rsp),%rax
mov    %rcx,0x130(%rsp)
lea    (%rcx,%rax,1),%r13
mov    %r13,%rax
mov    $0x1,%ecx
test   %r9b,%r9b
mov    %rdi,0xd0(%rsp)
mov    %rbp,0xc8(%rsp)
mov    %rsi,0x118(%rsp)
mov    %rbx,0x120(%rsp)
je     15d0 <wtn+0x4b0>
cmp    %rsi,0x38(%rsp)
jae    151e <wtn+0x3fe>
mov    %r13,%rax
mov    $0x1,%ecx
cmp    0xa8(%rsp),%rbx
jb     15d0 <wtn+0x4b0>
cmpq   $0x8,0x98(%rsp)
jae    152d <wtn+0x40d>
xor    %eax,%eax
jmp    1578 <wtn+0x458>
mov    0x70(%rsp),%rcx
xor    %esi,%esi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rdi,%rsi,1),%xmm0
movups (%rdi,%rsi,1),%xmm1
movups %xmm0,0x4(%r14,%rax,4)
movups %xmm1,0x14(%r14,%rax,4)
movups -0x10(%rbp,%rsi,1),%xmm0
movups 0x0(%rbp,%rsi,1),%xmm1
movups %xmm0,0x24(%r14,%rax,4)
movups %xmm1,0x34(%r14,%rax,4)
add    $0x10,%rax
add    %r11,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1540 <wtn+0x420>
testb  $0x1,0x90(%rsp)
01
je     15aa <wtn+0x48a>
mov    %rax,%rcx
imul   %r12,%rcx
add    %r13,%rcx
shl    $0x2,%rax
movups (%r10,%rcx,4),%xmm0
movups 0x10(%r10,%rcx,4),%xmm1
or     $0x4,%rax
movups %xmm0,(%r14,%rax,1)
movups %xmm1,0x10(%r14,%rax,1)
mov    0x88(%rsp),%rax
cmp    %rax,0x10(%rsp)
je     1689 <wtn+0x569>
mov    0x80(%rsp),%rax
add    %r13,%rax
mov    0x78(%rsp),%rcx
nopl   (%rax)
mov    0x50(%rsp),%rsi
sub    %ecx,%esi
mov    0x10(%rsp),%rdi
sub    %rcx,%rdi
and    $0x3,%rsi
je     1609 <wtn+0x4e9>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r10,%rax,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
add    $0x1,%rcx
add    %r12,%rax
add    $0xffffffffffffffff,%rsi
jne    15f0 <wtn+0x4d0>
cmp    $0x3,%rdi
jb     1689 <wtn+0x569>
lea    0x0(,%rax,4),%r8
mov    0xb0(%rsp),%rsi
lea    (%rsi,%rax,4),%r9
mov    0xb8(%rsp),%rsi
lea    (%rsi,%rax,4),%rdi
add    %r12,%rax
mov    0x10(%rsp),%rbp
sub    %rcx,%rbp
mov    0xa0(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
mov    $0xffffffffffffffff,%rbx
mov    %r10,%rsi
movss  (%rsi,%r8,1),%xmm0
movss  %xmm0,-0x8(%rcx,%rbx,4)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,-0x4(%rcx,%rbx,4)
movss  (%rsi,%rdi,1),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
movss  (%rsi,%r9,1),%xmm0
movss  %xmm0,0x4(%rcx,%rbx,4)
add    %r15,%rsi
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1650 <wtn+0x530>
test   %edx,%edx
js     16c0 <wtn+0x5a0>
mov    0x10(%rsp),%rbx
mov    %rbx,%rbp
mov    0xc0(%rsp),%r15
nopl   (%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
call   *%r15
mov    0x1c(%rsp),%edx
shr    %rbp
cmp    $0x7,%rbx
mov    %rbp,%rbx
ja     16a0 <wtn+0x580>
jmp    16e6 <wtn+0x5c6>
nopl   0x0(%rax,%rax,1)
mov    $0x4,%r15d
mov    0xc0(%rsp),%rbx
xchg   %ax,%ax
mov    %r14,%rdi
mov    %r15,%rsi
call   *%rbx
mov    0x1c(%rsp),%edx
add    %r15,%r15
cmp    0x10(%rsp),%r15
jbe    16d0 <wtn+0x5b0>
mov    $0x1,%eax
mov    0xf(%rsp),%r9b
test   %r9b,%r9b
je     171e <wtn+0x5fe>
mov    0x120(%rsp),%rcx
cmp    0xa8(%rsp),%rcx
jae    1800 <wtn+0x6e0>
mov    0x118(%rsp),%rcx
cmp    %rcx,0x38(%rsp)
jae    1800 <wtn+0x6e0>
mov    0x20(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0x28(%rsp),%r15
mov    0x50(%rsp),%rsi
sub    %eax,%esi
mov    0x10(%rsp),%rcx
sub    %rax,%rcx
and    $0x3,%rsi
je     1769 <wtn+0x649>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%r10,%r13,4)
add    $0x1,%rax
add    %r12,%r13
add    $0xffffffffffffffff,%rsi
jne    1750 <wtn+0x630>
cmp    $0x3,%rcx
jb     1460 <wtn+0x340>
lea    0x0(,%r13,4),%r8
mov    0xb0(%rsp),%rcx
lea    (%rcx,%r13,4),%rbx
mov    0xb8(%rsp),%rcx
lea    (%rcx,%r13,4),%rsi
add    %r12,%r13
mov    0x10(%rsp),%rdi
sub    %rax,%rdi
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    $0xffffffffffffffff,%rbp
mov    %r10,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x8(%rax,%rbp,4),%xmm0
movss  %xmm0,(%rcx,%r8,1)
movss  -0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,(%rcx,%r13,4)
movss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%rcx,%rsi,1)
movss  0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,(%rcx,%rbx,1)
add    %r15,%rcx
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    17c0 <wtn+0x6a0>
jmp    1460 <wtn+0x340>
xchg   %ax,%ax
cmpq   $0x8,0x98(%rsp)
mov    0x20(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0xd0(%rsp),%rdi
mov    0xc8(%rsp),%rbp
jae    182e <wtn+0x70e>
xor    %eax,%eax
mov    0x28(%rsp),%r15
jmp    1878 <wtn+0x758>
mov    0x70(%rsp),%rcx
xor    %esi,%esi
xor    %eax,%eax
mov    0x28(%rsp),%r15
nopl   0x0(%rax)
movups 0x4(%r14,%rax,4),%xmm0
movups 0x14(%r14,%rax,4),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm1,(%rdi,%rsi,1)
movups 0x24(%r14,%rax,4),%xmm0
movups 0x34(%r14,%rax,4),%xmm1
movups %xmm0,-0x10(%rbp,%rsi,1)
movups %xmm1,0x0(%rbp,%rsi,1)
add    $0x10,%rax
add    %r11,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1840 <wtn+0x720>
testb  $0x1,0x90(%rsp)
01
je     18aa <wtn+0x78a>
mov    %rax,%rcx
imul   %r12,%rcx
add    %r13,%rcx
shl    $0x2,%rax
or     $0x4,%rax
movups (%r14,%rax,1),%xmm0
movups 0x10(%r14,%rax,1),%xmm1
movups %xmm0,(%r10,%rcx,4)
movups %xmm1,0x10(%r10,%rcx,4)
mov    0x88(%rsp),%rax
cmp    %rax,0x10(%rsp)
je     1460 <wtn+0x340>
add    0x80(%rsp),%r13
mov    0x78(%rsp),%rax
jmp    172d <wtn+0x60d>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %rbp,%rdx
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>

LLVM IR (-O0):
define void @wtn(float* %0, i64* %1, i32 %2, i32 %3, void (float*, i64, i32)* %4) {
%6 = alloca float*
%7 = alloca i64*
%8 = alloca i32
%9 = alloca i32
%10 = alloca void (float*, i64, i32)*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i32
%21 = alloca float*
store float* %0, float** %6
store i64* %1, i64** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store void (float*, i64, i32)* %4, void (float*, i64, i32)** %10
store i64 1, i64* %17
store i64 1, i64* %19
store i32 1, i32* %20
br label %22
22: ; preds = %34, %5
%23 = load i32, i32* %20
%24 = load i32, i32* %8
%25 = icmp sle i32 %23, %24
br i1 %25, label %26, label %37
26: ; preds = %22
%27 = load i64*, i64** %7
%28 = load i32, i32* %20
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i64, i64* %27, i64 %29
%31 = load i64, i64* %30
%32 = load i64, i64* %19
%33 = mul i64 %32, %31
store i64 %33, i64* %19
br label %34
34: ; preds = %26
%35 = load i32, i32* %20
%36 = add nsw i32 %35, 1
store i32 %36, i32* %20
br label %22
37: ; preds = %22
%38 = load i64, i64* %19
%39 = call float* @vector(i32 1, i64 %38)
store float* %39, float** %21
store i32 1, i32* %20
br label %40
40: ; preds = %152, %37
%41 = load i32, i32* %20
%42 = load i32, i32* %8
%43 = icmp sle i32 %41, %42
br i1 %43, label %44, label %155
44: ; preds = %40
%45 = load i64*, i64** %7
%46 = load i32, i32* %20
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i64, i64* %45, i64 %47
%49 = load i64, i64* %48
store i64 %49, i64* %15
%50 = load i64, i64* %15
%51 = load i64, i64* %17
%52 = mul i64 %50, %51
store i64 %52, i64* %16
%53 = load i64, i64* %15
%54 = icmp ugt i64 %53, 4
br i1 %54, label %55, label %150
55: ; preds = %44
store i64 0, i64* %12
br label %56
56: ; preds = %145, %55
%57 = load i64, i64* %12
%58 = load i64, i64* %19
%59 = icmp ult i64 %57, %58
br i1 %59, label %60, label %149
60: ; preds = %56
store i64 1, i64* %11
br label %61
61: ; preds = %141, %60
%62 = load i64, i64* %11
%63 = load i64, i64* %17
%64 = icmp ule i64 %62, %63
br i1 %64, label %65, label %144
65: ; preds = %61
%66 = load i64, i64* %11
%67 = load i64, i64* %12
%68 = add i64 %66, %67
store i64 %68, i64* %13
store i64 1, i64* %14
br label %69
69: ; preds = %81, %65
%70 = load i64, i64* %14
%71 = load i64, i64* %15
%72 = icmp ule i64 %70, %71
br i1 %72, label %73, label %87
73: ; preds = %69
%74 = load float*, float** %6
%75 = load i64, i64* %13
%76 = getelementptr inbounds float, float* %74, i64 %75
%77 = load float, float* %76
%78 = load float*, float** %21
%79 = load i64, i64* %14
%80 = getelementptr inbounds float, float* %78, i64 %79
store float %77, float* %80
br label %81
81: ; preds = %73
%82 = load i64, i64* %14
%83 = add i64 %82, 1
store i64 %83, i64* %14
%84 = load i64, i64* %17
%85 = load i64, i64* %13
%86 = add i64 %85, %84
store i64 %86, i64* %13
br label %69
87: ; preds = %69
%88 = load i32, i32* %9
%89 = icmp sge i32 %88, 0
br i1 %89, label %90, label %104
90: ; preds = %87
%91 = load i64, i64* %15
store i64 %91, i64* %18
br label %92
92: ; preds = %100, %90
%93 = load i64, i64* %18
%94 = icmp uge i64 %93, 4
br i1 %94, label %95, label %103
95: ; preds = %92
%96 = load void (float*, i64, i32)*, void (float*, i64, i32)** %10
%97 = load float*, float** %21
%98 = load i64, i64* %18
%99 = load i32, i32* %9
br label %100
100: ; preds = %95
%101 = load i64, i64* %18
%102 = lshr i64 %101, 1
store i64 %102, i64* %18
br label %92
103: ; preds = %92
br label %118
104: ; preds = %87
store i64 4, i64* %18
br label %105
105: ; preds = %114, %104
%106 = load i64, i64* %18
%107 = load i64, i64* %15
%108 = icmp ule i64 %106, %107
br i1 %108, label %109, label %117
109: ; preds = %105
%110 = load void (float*, i64, i32)*, void (float*, i64, i32)** %10
%111 = load float*, float** %21
%112 = load i64, i64* %18
%113 = load i32, i32* %9
br label %114
114: ; preds = %109
%115 = load i64, i64* %18
%116 = shl i64 %115, 1
store i64 %116, i64* %18
br label %105
117: ; preds = %105
br label %118
118: ; preds = %117, %103
%119 = load i64, i64* %11
%120 = load i64, i64* %12
%121 = add i64 %119, %120
store i64 %121, i64* %13
store i64 1, i64* %14
br label %122
122: ; preds = %134, %118
%123 = load i64, i64* %14
%124 = load i64, i64* %15
%125 = icmp ule i64 %123, %124
br i1 %125, label %126, label %140
126: ; preds = %122
%127 = load float*, float** %21
%128 = load i64, i64* %14
%129 = getelementptr inbounds float, float* %127, i64 %128
%130 = load float, float* %129
%131 = load float*, float** %6
%132 = load i64, i64* %13
%133 = getelementptr inbounds float, float* %131, i64 %132
store float %130, float* %133
br label %134
134: ; preds = %126
%135 = load i64, i64* %14
%136 = add i64 %135, 1
store i64 %136, i64* %14
%137 = load i64, i64* %17
%138 = load i64, i64* %13
%139 = add i64 %138, %137
store i64 %139, i64* %13
br label %122
140: ; preds = %122
br label %141
141: ; preds = %140
%142 = load i64, i64* %11
%143 = add i64 %142, 1
store i64 %143, i64* %11
br label %61
144: ; preds = %61
br label %145
145: ; preds = %144
%146 = load i64, i64* %16
%147 = load i64, i64* %12
%148 = add i64 %147, %146
store i64 %148, i64* %12
br label %56
149: ; preds = %56
br label %150
150: ; preds = %149, %44
%151 = load i64, i64* %16
store i64 %151, i64* %17
br label %152
152: ; preds = %150
%153 = load i32, i32* %20
%154 = add nsw i32 %153, 1
store i32 %154, i32* %20
br label %40
155: ; preds = %40
%156 = load float*, float** %21
%157 = load i64, i64* %19
%158 = call i32 @free_vector(float* %156, i32 1, i64 %157)
ret void
}

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