#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 */
typedef int ntrap;

/* Variables and functions */
int /*<<< orphan*/ free(float *);
int /*<<< orphan*/ grd_rampup(float, float, float, float, int /*<<< orphan*/ *,
                              float **, int /*<<< orphan*/ *,
                              int /*<<< orphan*/ *, int *);
int /*<<< orphan*/ grd_trapezoid(float, float, float, float,
                                 int /*<<< orphan*/ *, float **,
                                 int /*<<< orphan*/ *, int /*<<< orphan*/ *,
                                 int *, int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(float *, float *, int);
int sumfloats(float *, int);
void grd_readout(int doDephase, int doRephase, int nread, float res, float gmax,
                 float smax, float Ts, float **g, int *nramp, int *ndep,
                 int *npts) {
  float G;
  float kmax = 5 / res;
  float *gramp, *gtrap;
  float kramp;
  int ntrap;
  int i;
  int offset;
  G = 2 * kmax / (4257 * nread * Ts);
  grd_rampup(gmax, smax, G, Ts, NULL, &gramp, NULL, NULL, nramp);
  kramp = 4257 * Ts * sumfloats(gramp, *nramp);
  grd_trapezoid(gmax, smax, -kmax - kramp, Ts, NULL, &gtrap, NULL, NULL, &ntrap,
                &i);
  *npts = (doDephase > 0) * (ntrap) + *nramp + nread + *nramp +
          (doRephase > 0) * (ntrap);
  *g = (float *)malloc(*npts * sizeof(float));
  if (doDephase) {
    memcpy(*g, gtrap, ntrap * sizeof(float));
    offset = ntrap;
    *ndep = ntrap + *nramp;
  } else {
    *ndep = *nramp;
    offset = 0;
  }
  memcpy(&(*g)[offset], gramp, *nramp * sizeof(float));
  offset += *nramp;
  for (i = 0; i < nread; i++)
    (*g)[i + offset] = G;
  offset += nread;
  for (i = 0; i < *nramp; i++)
    (*g)[i + offset] = gramp[*nramp - i - 1];
  offset += *nramp;
  if (doRephase)
    for (i = 0; i < ntrap; i++)
      (*g)[i + offset] = gtrap[i];
  free(gramp);
  free(gtrap);
  return;
}


x86 assembly (clang, -O0):
<grd_readout>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
movss  %xmm0,-0x10(%rbp)
movss  %xmm1,-0x14(%rbp)
movss  %xmm2,-0x18(%rbp)
movss  %xmm3,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movss  0xe6b(%rip),%xmm0
divss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xe55(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
imul   $0x10a1,-0xc(%rbp),%eax
cvtsi2ss %eax,%xmm1
mulss  -0x1c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm3
mov    -0x30(%rbp),%r8
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x48(%rbp),%rsi
mov    %rcx,%rdi
mov    %rcx,%rdx
call   1080 <grd_rampup@plt>
movss  0xe00(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    (%rax),%esi
call   1040 <sumfloats@plt>
movss  -0x64(%rbp),%xmm0
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
subss  -0x54(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm3
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x50(%rbp),%rsi
lea    -0x58(%rbp),%r8
lea    -0x5c(%rbp),%r9
mov    %rcx,%rdi
mov    %rcx,%rdx
call   1070 <grd_trapezoid@plt>
cmpl   $0x0,-0x4(%rbp)
setg   %al
and    $0x1,%al
movzbl %al,%ecx
imul   -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
add    (%rax),%ecx
add    -0xc(%rbp),%ecx
mov    -0x30(%rbp),%rax
add    (%rax),%ecx
cmpl   $0x0,-0x8(%rbp)
setg   %al
and    $0x1,%al
movzbl %al,%eax
imul   -0x58(%rbp),%eax
add    %eax,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    0x10(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
cmpl   $0x0,-0x4(%rbp)
je     12fd <grd_readout+0x19d>
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
mov    -0x50(%rbp),%rsi
movslq -0x58(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x58(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
add    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
jmp    1310 <grd_readout+0x1b0>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
movslq -0x60(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rsi
mov    -0x30(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    137f <grd_readout+0x21f>
movss  -0x3c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x5c(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    134b <grd_readout+0x1eb>
mov    -0xc(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
jge    13d9 <grd_readout+0x279>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x5c(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    138f <grd_readout+0x22f>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x8(%rbp)
je     1437 <grd_readout+0x2d7>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1432 <grd_readout+0x2d2>
mov    -0x50(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x5c(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13f6 <grd_readout+0x296>
jmp    1437 <grd_readout+0x2d7>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<grd_readout>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,%rbx
mov    %rcx,%r15
movss  %xmm3,0xc(%rsp)
movaps %xmm2,%xmm4
movss  %xmm2,0x30(%rsp)
movaps %xmm1,%xmm5
movss  %xmm1,0x2c(%rsp)
mov    %edx,%r13d
mov    %esi,%r12d
mov    %edi,%ebp
movss  0xe5f(%rip),%xmm2
imul   $0x10a1,%edx,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  %xmm0,%xmm2
movss  %xmm2,0x34(%rsp)
addss  %xmm2,%xmm2
mulss  %xmm3,%xmm1
divss  %xmm1,%xmm2
xor    %r14d,%r14d
lea    0x18(%rsp),%rsi
movaps %xmm5,%xmm0
movaps %xmm4,%xmm1
movaps %xmm2,0x40(%rsp)
xor    %edi,%edi
xor    %edx,%edx
xor    %ecx,%ecx
call   1080 <grd_rampup@plt>
movss  0xe1a(%rip),%xmm0
mulss  0xc(%rsp),%xmm0
movss  %xmm0,0x28(%rsp)
mov    0x18(%rsp),%rdi
mov    (%rbx),%esi
call   1040 <sumfloats@plt>
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mulss  0x28(%rsp),%xmm2
subss  0x34(%rsp),%xmm2
lea    0x20(%rsp),%rsi
lea    0x10(%rsp),%r8
lea    0x14(%rsp),%r9
movss  0x2c(%rsp),%xmm0
movss  0x30(%rsp),%xmm1
movss  0xc(%rsp),%xmm3
xor    %edi,%edi
xor    %edx,%edx
xor    %ecx,%ecx
call   1070 <grd_trapezoid@plt>
mov    0x10(%rsp),%eax
test   %ebp,%ebp
mov    $0x0,%ecx
cmovg  %eax,%ecx
mov    (%rbx),%edx
mov    %r12d,0xc(%rsp)
test   %r12d,%r12d
cmovle %r14d,%eax
add    %r13d,%ecx
add    %eax,%ecx
lea    (%rcx,%rdx,2),%edi
mov    0x90(%rsp),%rax
mov    %edi,(%rax)
shl    $0x2,%edi
call   1060 <malloc@plt>
mov    %rax,(%r15)
test   %ebp,%ebp
je     12a1 <grd_readout+0x141>
mov    0x20(%rsp),%rsi
mov    0x10(%rsp),%edx
shl    $0x2,%edx
mov    %rax,%rdi
call   1050 <memcpy@plt>
mov    0x10(%rsp),%r14d
mov    (%rbx),%ecx
add    %r14d,%ecx
mov    (%r15),%rax
jmp    12a3 <grd_readout+0x143>
mov    (%rbx),%ecx
mov    0x38(%rsp),%rdx
mov    %ecx,(%rdx)
movslq %r14d,%r14
lea    (%rax,%r14,4),%rdi
mov    0x18(%rsp),%rsi
mov    (%rbx),%edx
shl    $0x2,%edx
call   1050 <memcpy@plt>
mov    (%rbx),%eax
add    %eax,%r14d
test   %r13d,%r13d
movaps 0x40(%rsp),%xmm1
jle    13ae <grd_readout+0x24e>
mov    (%r15),%r8
movslq %r14d,%r9
mov    %r13d,%ecx
cmp    $0x8,%r13d
jae    12e9 <grd_readout+0x189>
xor    %edx,%edx
jmp    1397 <grd_readout+0x237>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movaps %xmm1,%xmm0
shufps $0x0,%xmm1,%xmm0
lea    -0x8(%rdx),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%esi
and    $0x3,%esi
cmp    $0x18,%rdi
jae    1313 <grd_readout+0x1b3>
xor    %edi,%edi
jmp    1362 <grd_readout+0x202>
and    $0xfffffffffffffffc,%rbx
lea    (%r8,%r9,4),%rbp
add    $0x70,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups %xmm0,-0x70(%rbp,%rdi,4)
movups %xmm0,-0x60(%rbp,%rdi,4)
movups %xmm0,-0x50(%rbp,%rdi,4)
movups %xmm0,-0x40(%rbp,%rdi,4)
movups %xmm0,-0x30(%rbp,%rdi,4)
movups %xmm0,-0x20(%rbp,%rdi,4)
movups %xmm0,-0x10(%rbp,%rdi,4)
movups %xmm0,0x0(%rbp,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rbx
jne    1330 <grd_readout+0x1d0>
test   %rsi,%rsi
je     1392 <grd_readout+0x232>
add    %r9,%rdi
lea    (%r8,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm0,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1380 <grd_readout+0x220>
cmp    %rcx,%rdx
je     13ae <grd_readout+0x24e>
lea    (%r8,%r9,4),%rsi
nopl   0x0(%rax,%rax,1)
movss  %xmm1,(%rsi,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    13a0 <grd_readout+0x240>
add    %r13d,%r14d
test   %eax,%eax
jle    144e <grd_readout+0x2ee>
mov    0x18(%rsp),%rcx
mov    (%r15),%r9
movslq %r14d,%r10
cmp    $0x8,%eax
jae    1529 <grd_readout+0x3c9>
xor    %r11d,%r11d
mov    0xc(%rsp),%r12d
mov    %r11,%rdx
not    %rdx
test   $0x1,%al
je     13fc <grd_readout+0x29c>
mov    %r11d,%esi
not    %esi
add    %eax,%esi
movslq %esi,%rsi
movss  (%rcx,%rsi,4),%xmm0
lea    (%r11,%r10,1),%rsi
movss  %xmm0,(%r9,%rsi,4)
or     $0x1,%r11
mov    %eax,%esi
add    %rax,%rdx
je     1455 <grd_readout+0x2f5>
mov    %rax,%rdx
sub    %r11,%rdx
mov    %r11d,%esi
not    %esi
add    %eax,%esi
add    %r11,%r10
lea    (%r9,%r10,4),%rdi
add    $0x4,%rdi
xor    %ebp,%ebp
nopl   (%rax)
movslq %esi,%rsi
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rdi,%rbp,4)
lea    -0x1(%rsi),%ebx
movslq %ebx,%rbx
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rdi,%rbp,4)
add    $0x2,%rbp
add    $0xfffffffe,%esi
cmp    %rbp,%rdx
jne    1420 <grd_readout+0x2c0>
mov    %eax,%esi
jmp    1455 <grd_readout+0x2f5>
xor    %esi,%esi
mov    0xc(%rsp),%r12d
mov    %esi,0x14(%rsp)
test   %r12d,%r12d
je     1588 <grd_readout+0x428>
mov    0x10(%rsp),%ecx
test   %ecx,%ecx
jle    1582 <grd_readout+0x422>
add    %eax,%r14d
mov    0x20(%rsp),%rax
mov    (%r15),%r8
movslq %r14d,%r9
cmp    $0x8,%ecx
jb     14a3 <grd_readout+0x343>
lea    (%r8,%r9,4),%rdx
lea    (%rax,%rcx,4),%rsi
cmp    %rsi,%rdx
jae    15ab <grd_readout+0x44b>
lea    (%r9,%rcx,1),%rdx
lea    (%r8,%rdx,4),%rdx
cmp    %rdx,%rax
jae    15ab <grd_readout+0x44b>
xor    %edi,%edi
mov    %rdi,%rdx
not    %rdx
add    %rcx,%rdx
mov    %rcx,%rsi
and    $0x3,%rsi
je     14d5 <grd_readout+0x375>
lea    (%r8,%r9,4),%rbp
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    14c0 <grd_readout+0x360>
cmp    $0x3,%rdx
jb     1584 <grd_readout+0x424>
lea    (%r8,%r9,4),%rdx
add    $0xc,%rdx
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rdx,%rdi,4)
movss  0x4(%rax,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rdi,4)
movss  0x8(%rax,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rdi,4)
movss  0xc(%rax,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    14f0 <grd_readout+0x390>
jmp    1584 <grd_readout+0x424>
lea    -0x1(%rax),%rsi
lea    -0x1(%rax),%edx
mov    %edx,%edi
sub    %esi,%edi
xor    %r11d,%r11d
cmp    %edx,%edi
mov    0xc(%rsp),%r12d
jg     13d5 <grd_readout+0x275>
shr    $0x20,%rsi
jne    13d5 <grd_readout+0x275>
lea    (%r9,%r10,4),%rsi
movslq %edx,%rdx
lea    (%rcx,%rdx,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    15d5 <grd_readout+0x475>
lea    (%r10,%rax,1),%rsi
lea    (%r9,%rsi,4),%rsi
add    $0x1,%rdx
sub    %rax,%rdx
lea    (%rcx,%rdx,4),%rdx
cmp    %rsi,%rdx
jae    15d5 <grd_readout+0x475>
xor    %r11d,%r11d
jmp    13d5 <grd_readout+0x275>
xor    %ecx,%ecx
mov    %ecx,0x14(%rsp)
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ecx,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %ebp,%ebx
and    $0x3,%ebx
cmp    $0x18,%rdx
jae    16ac <grd_readout+0x54c>
xor    %edx,%edx
jmp    1718 <grd_readout+0x5b8>
mov    %eax,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1769 <grd_readout+0x609>
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
or     $0x2,%rdx
and    %r8,%rdx
lea    -0x9(%rax),%esi
lea    (%r9,%r10,4),%rdi
add    $0x30,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x8(%rsi),%ebp
movslq %ebp,%rbp
movups -0x1c(%rcx,%rbp,4),%xmm0
movups -0xc(%rcx,%rbp,4),%xmm1
shufps $0x1b,%xmm1,%xmm1
shufps $0x1b,%xmm0,%xmm0
movups %xmm1,-0x30(%rdi,%rbx,4)
movups %xmm0,-0x20(%rdi,%rbx,4)
movslq %esi,%rsi
movups -0x1c(%rcx,%rsi,4),%xmm0
movups -0xc(%rcx,%rsi,4),%xmm1
shufps $0x1b,%xmm1,%xmm1
shufps $0x1b,%xmm0,%xmm0
movups %xmm1,-0x10(%rdi,%rbx,4)
movups %xmm0,(%rdi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffff0,%esi
add    $0xfffffffffffffffe,%rdx
jne    1620 <grd_readout+0x4c0>
test   $0x1,%r8b
je     169c <grd_readout+0x53c>
mov    %ebx,%edx
not    %edx
add    %eax,%edx
movslq %edx,%rdx
movups -0x1c(%rcx,%rdx,4),%xmm0
movups -0xc(%rcx,%rdx,4),%xmm1
shufps $0x1b,%xmm1,%xmm1
shufps $0x1b,%xmm0,%xmm0
add    %r10,%rbx
movups %xmm1,(%r9,%rbx,4)
movups %xmm0,0x10(%r9,%rbx,4)
mov    %eax,%esi
cmp    %rax,%r11
jne    13d5 <grd_readout+0x275>
jmp    1455 <grd_readout+0x2f5>
and    $0xfffffffffffffffc,%rbp
lea    (%r8,%r9,4),%rsi
add    $0x70,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups %xmm0,-0x70(%rsi,%rdx,4)
movups %xmm1,-0x60(%rsi,%rdx,4)
movups 0x20(%rax,%rdx,4),%xmm0
movups 0x30(%rax,%rdx,4),%xmm1
movups %xmm0,-0x50(%rsi,%rdx,4)
movups %xmm1,-0x40(%rsi,%rdx,4)
movups 0x40(%rax,%rdx,4),%xmm0
movups 0x50(%rax,%rdx,4),%xmm1
movups %xmm0,-0x30(%rsi,%rdx,4)
movups %xmm1,-0x20(%rsi,%rdx,4)
movups 0x60(%rax,%rdx,4),%xmm0
movups 0x70(%rax,%rdx,4),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,4)
movups %xmm1,(%rsi,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbp
jne    16c0 <grd_readout+0x560>
test   %rbx,%rbx
je     175b <grd_readout+0x5fb>
lea    (%rdx,%r9,1),%rsi
lea    (%r8,%rsi,4),%rsi
add    $0x10,%rsi
lea    (%rax,%rdx,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rbp,1),%xmm0
movups (%rdx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    1740 <grd_readout+0x5e0>
cmp    %rcx,%rdi
je     1584 <grd_readout+0x424>
jmp    14a5 <grd_readout+0x345>
xor    %ebx,%ebx
test   $0x1,%r8b
jne    1673 <grd_readout+0x513>
jmp    169c <grd_readout+0x53c>

LLVM IR (-O0):
define void @grd_readout(i32 %0, i32 %1, i32 %2, float %3, float %4, float %5, float %6, float** %7, i32* %8, i32* %9, i32* %10) {
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float**
%20 = alloca i32*
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca float
%24 = alloca float
%25 = alloca float*
%26 = alloca float*
%27 = alloca float
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store i32 %0, i32* %12
store i32 %1, i32* %13
store i32 %2, i32* %14
store float %3, float* %15
store float %4, float* %16
store float %5, float* %17
store float %6, float* %18
store float** %7, float*** %19
store i32* %8, i32** %20
store i32* %9, i32** %21
store i32* %10, i32** %22
%31 = load float, float* %15
%32 = fdiv float 5.000000e+00, %31
store float %32, float* %24
%33 = load float, float* %24
%34 = fmul float 2.000000e+00, %33
%35 = load i32, i32* %14
%36 = mul nsw i32 4257, %35
%37 = sitofp i32 %36 to float
%38 = load float, float* %18
%39 = fmul float %37, %38
%40 = fdiv float %34, %39
store float %40, float* %23
%41 = load float, float* %16
%42 = load float, float* %17
%43 = load float, float* %23
%44 = load float, float* %18
%45 = load i32*, i32** %20
%46 = call i32 @grd_rampup(float %41, float %42, float %43, float %44, i32* null, float** %25, i32* null, i32* null, i32* %45)
%47 = load float, float* %18
%48 = fmul float 4.257000e+03, %47
%49 = load float*, float** %25
%50 = load i32*, i32** %20
%51 = load i32, i32* %50
%52 = call i32 @sumfloats(float* %49, i32 %51)
%53 = sitofp i32 %52 to float
%54 = fmul float %48, %53
store float %54, float* %27
%55 = load float, float* %16
%56 = load float, float* %17
%57 = load float, float* %24
%58 = fneg float %57
%59 = load float, float* %27
%60 = fsub float %58, %59
%61 = load float, float* %18
%62 = call i32 @grd_trapezoid(float %55, float %56, float %60, float %61, i32* null, float** %26, i32* null, i32* null, i32* %28, i32* %29)
%63 = load i32, i32* %12
%64 = icmp sgt i32 %63, 0
%65 = zext i1 %64 to i32
%66 = load i32, i32* %28
%67 = mul nsw i32 %65, %66
%68 = load i32*, i32** %20
%69 = load i32, i32* %68
%70 = add nsw i32 %67, %69
%71 = load i32, i32* %14
%72 = add nsw i32 %70, %71
%73 = load i32*, i32** %20
%74 = load i32, i32* %73
%75 = add nsw i32 %72, %74
%76 = load i32, i32* %13
%77 = icmp sgt i32 %76, 0
%78 = zext i1 %77 to i32
%79 = load i32, i32* %28
%80 = mul nsw i32 %78, %79
%81 = add nsw i32 %75, %80
%82 = load i32*, i32** %22
store i32 %81, i32* %82
%83 = load i32*, i32** %22
%84 = load i32, i32* %83
%85 = sext i32 %84 to i64
%86 = mul i64 %85, 4
%87 = trunc i64 %86 to i32
%88 = call i64 @malloc(i32 %87)
%89 = inttoptr i64 %88 to float*
%90 = load float**, float*** %19
store float* %89, float** %90
%91 = load i32, i32* %12
%92 = icmp ne i32 %91, 0
br i1 %92, label %93, label %108
93: ; preds = %11
%94 = load float**, float*** %19
%95 = load float*, float** %94
%96 = load float*, float** %26
%97 = load i32, i32* %28
%98 = sext i32 %97 to i64
%99 = mul i64 %98, 4
%100 = trunc i64 %99 to i32
%101 = call i32 @memcpy(float* %95, float* %96, i32 %100)
%102 = load i32, i32* %28
store i32 %102, i32* %30
%103 = load i32, i32* %28
%104 = load i32*, i32** %20
%105 = load i32, i32* %104
%106 = add nsw i32 %103, %105
%107 = load i32*, i32** %21
store i32 %106, i32* %107
br label %112
108: ; preds = %11
%109 = load i32*, i32** %20
%110 = load i32, i32* %109
%111 = load i32*, i32** %21
store i32 %110, i32* %111
store i32 0, i32* %30
br label %112
112: ; preds = %108, %93
%113 = load float**, float*** %19
%114 = load float*, float** %113
%115 = load i32, i32* %30
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %114, i64 %116
%118 = load float*, float** %25
%119 = load i32*, i32** %20
%120 = load i32, i32* %119
%121 = sext i32 %120 to i64
%122 = mul i64 %121, 4
%123 = trunc i64 %122 to i32
%124 = call i32 @memcpy(float* %117, float* %118, i32 %123)
%125 = load i32*, i32** %20
%126 = load i32, i32* %125
%127 = load i32, i32* %30
%128 = add nsw i32 %127, %126
store i32 %128, i32* %30
store i32 0, i32* %29
br label %129
129: ; preds = %142, %112
%130 = load i32, i32* %29
%131 = load i32, i32* %14
%132 = icmp slt i32 %130, %131
br i1 %132, label %133, label %145
133: ; preds = %129
%134 = load float, float* %23
%135 = load float**, float*** %19
%136 = load float*, float** %135
%137 = load i32, i32* %29
%138 = load i32, i32* %30
%139 = add nsw i32 %137, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %136, i64 %140
store float %134, float* %141
br label %142
142: ; preds = %133
%143 = load i32, i32* %29
%144 = add nsw i32 %143, 1
store i32 %144, i32* %29
br label %129
145: ; preds = %129
%146 = load i32, i32* %14
%147 = load i32, i32* %30
%148 = add nsw i32 %147, %146
store i32 %148, i32* %30
store i32 0, i32* %29
br label %149
149: ; preds = %171, %145
%150 = load i32, i32* %29
%151 = load i32*, i32** %20
%152 = load i32, i32* %151
%153 = icmp slt i32 %150, %152
br i1 %153, label %154, label %174
154: ; preds = %149
%155 = load float*, float** %25
%156 = load i32*, i32** %20
%157 = load i32, i32* %156
%158 = load i32, i32* %29
%159 = sub nsw i32 %157, %158
%160 = sub nsw i32 %159, 1
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float, float* %155, i64 %161
%163 = load float, float* %162
%164 = load float**, float*** %19
%165 = load float*, float** %164
%166 = load i32, i32* %29
%167 = load i32, i32* %30
%168 = add nsw i32 %166, %167
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %165, i64 %169
store float %163, float* %170
br label %171
171: ; preds = %154
%172 = load i32, i32* %29
%173 = add nsw i32 %172, 1
store i32 %173, i32* %29
br label %149
174: ; preds = %149
%175 = load i32*, i32** %20
%176 = load i32, i32* %175
%177 = load i32, i32* %30
%178 = add nsw i32 %177, %176
store i32 %178, i32* %30
%179 = load i32, i32* %13
%180 = icmp ne i32 %179, 0
br i1 %180, label %181, label %203
181: ; preds = %174
store i32 0, i32* %29
br label %182
182: ; preds = %199, %181
%183 = load i32, i32* %29
%184 = load i32, i32* %28
%185 = icmp slt i32 %183, %184
br i1 %185, label %186, label %202
186: ; preds = %182
%187 = load float*, float** %26
%188 = load i32, i32* %29
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float, float* %187, i64 %189
%191 = load float, float* %190
%192 = load float**, float*** %19
%193 = load float*, float** %192
%194 = load i32, i32* %29
%195 = load i32, i32* %30
%196 = add nsw i32 %194, %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %193, i64 %197
store float %191, float* %198
br label %199
199: ; preds = %186
%200 = load i32, i32* %29
%201 = add nsw i32 %200, 1
store i32 %201, i32* %29
br label %182
202: ; preds = %182
br label %203
203: ; preds = %202, %174
%204 = load float*, float** %25
%205 = call i32 @free(float* %204)
%206 = load float*, float** %26
%207 = call i32 @free(float* %206)
ret void
}

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