#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 ceil(float);
int /*<<< orphan*/ cumulativeSum(float *, float *, int);
int /*<<< orphan*/ diffArray(float *, float *, int);
int fabs(float);
int /*<<< orphan*/ grd_triangle(float, float, float, float, float **, float **,
                                float **, float **, int *, int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, float);
int /*<<< orphan*/ scalefloats(float *, int, int);
int sumfloats(float *, int);
void grd_trapezoid(float GMAX, float SMAX, float Ktgt, float Ts, float **kx,
                   float **gx, float **slew, float **time, int *N, int *Nrout) {
  float T_ramp;
  float T_plateau;
  int Nr;
  int Npl;
  int Ngx;
  float scaling;
  int n;
  if (fabs(Ktgt) < 4257 * (GMAX * GMAX) / SMAX) {
    grd_triangle(GMAX, SMAX, Ktgt, Ts, kx, gx, slew, time, N, &n);
    return;
  }
  T_ramp = GMAX / SMAX;
  T_plateau = fabs(Ktgt) / GMAX / 4257 - T_ramp;
  Nr = T_ramp / Ts;
  Npl = ceil(T_plateau / Ts) + 3;
  Ngx = 2 * Nr + Npl;
  *gx = (float *)malloc(Ngx * sizeof(float));
  for (n = 0; n < Nr; n++)
    (*gx)[n] = n * Ts * SMAX;
  for (n = Nr; n < (Nr + Npl); n++)
    (*gx)[n] = (*gx)[Nr - 1];
  for (n = 0; n < Nr; n++)
    (*gx)[Nr + Npl + n] = (*gx)[Nr - 1 - n];
  scaling = Ktgt / (sumfloats((*gx), Ngx) * 4257 * Ts);
  if (fabs(scaling) > 1 && 1)
    printf("grd_trapezoid: abs(scaling)=%.2f> 1 !\n", scaling);
  scalefloats(*gx, Ngx, scaling);
  if (kx) {
    *kx = (float *)malloc(Ngx * sizeof(float));
    cumulativeSum(*gx, *kx, Ngx);
    scalefloats(*kx, Ngx, 4257 * Ts);
  }
  if (slew) {
    *slew = (float *)malloc(Ngx * sizeof(float));
    diffArray(*gx, *slew, Ngx);
    scalefloats(*slew, Ngx, 1 / Ts);
  }
  if (time) {
    *time = (float *)malloc(Ngx * sizeof(float));
    for (n = 0; n < Ngx; n++)
      (*time)[n] = n * Ts;
  }
  *N = Ngx;
  *Nrout = Nr;
  return;
}


x86 assembly (clang, -O0):
<grd_trapezoid>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
movss  -0xc(%rbp),%xmm0
call   1060 <fabs@plt>
cvtsi2ss %eax,%xmm1
movss  -0x4(%rbp),%xmm2
mulss  -0x4(%rbp),%xmm2
movss  0xe1c(%rip),%xmm0
mulss  %xmm2,%xmm0
divss  -0x8(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    122c <grd_trapezoid+0x9c>
movss  -0x4(%rbp),%xmm0
movss  -0x8(%rbp),%xmm1
movss  -0xc(%rbp),%xmm2
movss  -0x10(%rbp),%xmm3
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
lea    -0x5c(%rbp),%r9
call   10a0 <grd_triangle@plt>
jmp    1522 <grd_trapezoid+0x392>
movss  -0x4(%rbp),%xmm0
divss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0xc(%rbp),%xmm0
call   1060 <fabs@plt>
cvtsi2ss %eax,%xmm0
divss  -0x4(%rbp),%xmm0
movss  0xdaa(%rip),%xmm1
divss  %xmm1,%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
divss  -0x10(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
divss  -0x10(%rbp),%xmm0
call   1040 <ceil@plt>
add    $0x3,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
movslq -0x54(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    12ef <grd_trapezoid+0x15f>
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12b6 <grd_trapezoid+0x126>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    -0x50(%rbp),%ecx
cmp    %ecx,%eax
jge    1339 <grd_trapezoid+0x1a9>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12f5 <grd_trapezoid+0x165>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    138a <grd_trapezoid+0x1fa>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x4c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1340 <grd_trapezoid+0x1b0>
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x54(%rbp),%esi
call   1070 <sumfloats@plt>
movss  -0x60(%rbp),%xmm0
imul   $0x10a1,%eax,%eax
cvtsi2ss %eax,%xmm1
mulss  -0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
call   1060 <fabs@plt>
cmp    $0x1,%eax
jle    13e4 <grd_trapezoid+0x254>
movss  -0x58(%rbp),%xmm0
lea    0xc29(%rip),%rdi
call   1050 <printf@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x54(%rbp),%esi
cvttss2si -0x58(%rbp),%edx
call   1030 <scalefloats@plt>
cmpq   $0x0,-0x18(%rbp)
je     1452 <grd_trapezoid+0x2c2>
movslq -0x54(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x18(%rbp),%rax
mov    (%rax),%rsi
mov    -0x54(%rbp),%edx
call   10b0 <cumulativeSum@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x54(%rbp),%esi
movss  0xbbc(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
cvttss2si %xmm0,%edx
call   1030 <scalefloats@plt>
cmpq   $0x0,-0x28(%rbp)
je     14ac <grd_trapezoid+0x31c>
movslq -0x54(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x28(%rbp),%rax
mov    (%rax),%rsi
mov    -0x54(%rbp),%edx
call   1080 <diffArray@plt>
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
mov    -0x54(%rbp),%esi
movss  0xb66(%rip),%xmm0
divss  -0x10(%rbp),%xmm0
cvttss2si %xmm0,%edx
call   1030 <scalefloats@plt>
cmpq   $0x0,-0x30(%rbp)
je     1510 <grd_trapezoid+0x380>
movslq -0x54(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    150b <grd_trapezoid+0x37b>
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    14d7 <grd_trapezoid+0x347>
jmp    1510 <grd_trapezoid+0x380>
mov    -0x54(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    %ecx,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<grd_trapezoid>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,%r14
mov    %r8,%r15
mov    %rcx,%r13
mov    %rdx,%rbp
mov    %rsi,%r12
mov    %rdi,%rbx
movaps %xmm3,0x10(%rsp)
movaps %xmm1,0x50(%rsp)
movss  %xmm0,0x8(%rsp)
movss  %xmm2,0xc(%rsp)
movaps %xmm2,%xmm0
call   1060 <fabs@plt>
movss  0x8(%rsp),%xmm0
movaps 0x50(%rsp),%xmm1
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
movaps %xmm0,%xmm2
mulss  %xmm0,%xmm2
mulss  0xe11(%rip),%xmm2
divss  %xmm1,%xmm2
ucomiss %xmm3,%xmm2
jbe    1221 <grd_trapezoid+0x91>
lea    0x2c(%rsp),%r9
movss  0xc(%rsp),%xmm2
movaps 0x10(%rsp),%xmm3
mov    %rbx,%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
mov    %r13,%rcx
mov    %r15,%r8
call   10a0 <grd_triangle@plt>
jmp    16c8 <grd_trapezoid+0x538>
mov    %rbx,0x30(%rsp)
mov    %rbp,0x38(%rsp)
mov    %r15,0x40(%rsp)
mov    %r13,%rbx
mov    %r14,0x48(%rsp)
divss  %xmm1,%xmm0
movss  %xmm0,0x28(%rsp)
movss  0xc(%rsp),%xmm0
call   1060 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  0x8(%rsp),%xmm0
divss  0xd9e(%rip),%xmm0
movss  0x28(%rsp),%xmm2
subss  %xmm2,%xmm0
movaps 0x10(%rsp),%xmm1
divss  %xmm1,%xmm2
cvttss2si %xmm2,%r14d
divss  %xmm1,%xmm0
call   1040 <ceil@plt>
mov    %eax,%r15d
lea    0x3(%r15),%r13d
lea    (%r15,%r14,2),%ebp
add    $0x3,%ebp
lea    0x0(,%rbp,4),%edi
mov    %edi,0x8(%rsp)
call   1090 <malloc@plt>
movaps 0x50(%rsp),%xmm5
mov    %rax,(%r12)
mov    %r14d,%r8d
test   %r14d,%r14d
movaps 0x10(%rsp),%xmm4
jle    13ed <grd_trapezoid+0x25d>
cmp    $0x8,%r14d
jae    12c8 <grd_trapezoid+0x138>
xor    %edx,%edx
jmp    13d0 <grd_trapezoid+0x240>
mov    %rbp,%rcx
mov    %r8d,%edx
and    $0xfffffff8,%edx
movaps %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm1
movaps %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     16d7 <grd_trapezoid+0x547>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xd0a(%rip),%xmm2
xor    %esi,%esi
movdqa 0xd0f(%rip),%xmm8
movdqa 0xd16(%rip),%xmm9
movdqa 0xd1d(%rip),%xmm10
movdqa 0xd25(%rip),%xmm6
nopl   0x0(%rax,%rax,1)
movdqa %xmm2,%xmm7
paddd  %xmm8,%xmm7
cvtdq2ps %xmm2,%xmm3
cvtdq2ps %xmm7,%xmm7
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm7
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm7
movups %xmm3,(%rax,%rsi,4)
movups %xmm7,0x10(%rax,%rsi,4)
movdqa %xmm2,%xmm3
paddd  %xmm9,%xmm3
movdqa %xmm2,%xmm7
paddd  %xmm10,%xmm7
cvtdq2ps %xmm3,%xmm3
cvtdq2ps %xmm7,%xmm7
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm7
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm7
movups %xmm3,0x20(%rax,%rsi,4)
movups %xmm7,0x30(%rax,%rsi,4)
add    $0x10,%rsi
paddd  %xmm6,%xmm2
add    $0xfffffffffffffffe,%rdi
jne    1330 <grd_trapezoid+0x1a0>
test   $0x1,%bpl
je     13b9 <grd_trapezoid+0x229>
cvtdq2ps %xmm2,%xmm3
paddd  0xc7f(%rip),%xmm2
cvtdq2ps %xmm2,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm2
movups %xmm3,(%rax,%rsi,4)
movups %xmm2,0x10(%rax,%rsi,4)
cmp    %r8,%rdx
mov    %rcx,%rbp
je     13ed <grd_trapezoid+0x25d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm4,%xmm0
mulss  %xmm5,%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    13d0 <grd_trapezoid+0x240>
add    %r14d,%r13d
movslq %r13d,%rdx
cmp    $0xfffffffe,%r15d
jl     1423 <grd_trapezoid+0x293>
lea    -0x1(%r14),%esi
movslq %esi,%rsi
movslq %r14d,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x1,%rdi
cmp    %rdx,%rdi
jl     1410 <grd_trapezoid+0x280>
test   %r14d,%r14d
mov    %rbx,%r15
mov    0x38(%rsp),%r13
jle    143d <grd_trapezoid+0x2ad>
mov    %rbp,%r10
cmp    $0x1,%r14d
jne    1441 <grd_trapezoid+0x2b1>
xor    %esi,%esi
jmp    148a <grd_trapezoid+0x2fa>
xor    %edi,%edi
jmp    14b0 <grd_trapezoid+0x320>
mov    %r8d,%edi
and    $0xfffffffe,%edi
lea    -0x2(%r14),%ebp
lea    (%rax,%rdx,4),%rbx
add    $0x4,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rsi,4)
movslq %ebp,%rbp
movss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%rbx,%rsi,4)
add    $0x2,%rsi
add    $0xfffffffe,%ebp
cmp    %rsi,%rdi
jne    1460 <grd_trapezoid+0x2d0>
mov    %r14d,%edi
test   $0x1,%r8b
mov    %r10,%rbp
je     14b0 <grd_trapezoid+0x320>
mov    %esi,%ecx
not    %ecx
add    %r14d,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
add    %rsi,%rdx
movss  %xmm0,(%rax,%rdx,4)
mov    %r14d,%edi
mov    %edi,0x2c(%rsp)
mov    %rax,%rdi
mov    %ebp,%esi
call   1070 <sumfloats@plt>
imul   $0x10a1,%eax,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
mulss  0x10(%rsp),%xmm1
movss  0xc(%rsp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc(%rsp)
call   1060 <fabs@plt>
cmp    $0x2,%eax
jl     14fd <grd_trapezoid+0x36d>
lea    0xb6e(%rip),%rdi
movss  0xc(%rsp),%xmm0
call   1050 <printf@plt>
mov    (%r12),%rdi
cvttss2si 0xc(%rsp),%edx
mov    %ebp,%esi
call   1030 <scalefloats@plt>
mov    0x30(%rsp),%rbx
test   %rbx,%rbx
je     154e <grd_trapezoid+0x3be>
mov    0x8(%rsp),%edi
call   1090 <malloc@plt>
mov    %rax,(%rbx)
mov    (%r12),%rdi
mov    %rax,%rsi
mov    %ebp,%edx
call   10b0 <cumulativeSum@plt>
mov    (%rbx),%rdi
movss  0xac3(%rip),%xmm0
mulss  0x10(%rsp),%xmm0
cvttss2si %xmm0,%edx
mov    %ebp,%esi
call   1030 <scalefloats@plt>
test   %r13,%r13
je     158b <grd_trapezoid+0x3fb>
mov    0x8(%rsp),%edi
call   1090 <malloc@plt>
mov    %rax,0x0(%r13)
mov    (%r12),%rdi
mov    %rax,%rsi
mov    %ebp,%edx
call   1080 <diffArray@plt>
mov    0x0(%r13),%rdi
movss  0xa8a(%rip),%xmm0
divss  0x10(%rsp),%xmm0
cvttss2si %xmm0,%edx
mov    %ebp,%esi
call   1030 <scalefloats@plt>
test   %r15,%r15
je     16b9 <grd_trapezoid+0x529>
mov    0x8(%rsp),%edi
call   1090 <malloc@plt>
movaps 0x10(%rsp),%xmm2
mov    %rax,(%r15)
test   %ebp,%ebp
jle    16b9 <grd_trapezoid+0x529>
mov    %ebp,%ecx
cmp    $0x8,%ebp
jae    15bb <grd_trapezoid+0x42b>
xor    %edx,%edx
jmp    16a0 <grd_trapezoid+0x510>
mov    %rbp,%r8
mov    %ecx,%edx
and    $0xfffffff8,%edx
movaps %xmm2,%xmm0
shufps $0x0,%xmm2,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     16f0 <grd_trapezoid+0x560>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xa1f(%rip),%xmm1
xor    %esi,%esi
movdqa 0xa24(%rip),%xmm8
movdqa 0xa2c(%rip),%xmm3
movdqa 0xa34(%rip),%xmm4
movdqa 0xa3c(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm1,%xmm6
paddd  %xmm8,%xmm6
cvtdq2ps %xmm1,%xmm7
cvtdq2ps %xmm6,%xmm6
mulps  %xmm0,%xmm7
mulps  %xmm0,%xmm6
movups %xmm7,(%rax,%rsi,4)
movups %xmm6,0x10(%rax,%rsi,4)
movdqa %xmm1,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm1,%xmm7
paddd  %xmm4,%xmm7
cvtdq2ps %xmm6,%xmm6
cvtdq2ps %xmm7,%xmm7
mulps  %xmm0,%xmm6
mulps  %xmm0,%xmm7
movups %xmm6,0x20(%rax,%rsi,4)
movups %xmm7,0x30(%rax,%rsi,4)
add    $0x10,%rsi
paddd  %xmm5,%xmm1
add    $0xfffffffffffffffe,%rdi
jne    1620 <grd_trapezoid+0x490>
test   $0x1,%bpl
je     1695 <grd_trapezoid+0x505>
cvtdq2ps %xmm1,%xmm3
paddd  0x99d(%rip),%xmm1
cvtdq2ps %xmm1,%xmm1
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm1
movups %xmm3,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
cmp    %rcx,%rdx
mov    %r8,%rbp
je     16b9 <grd_trapezoid+0x529>
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm2,%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    16a0 <grd_trapezoid+0x510>
mov    0x40(%rsp),%rax
mov    %ebp,(%rax)
mov    0x48(%rsp),%rax
mov    %r14d,(%rax)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movdqa 0x931(%rip),%xmm2
xor    %esi,%esi
test   $0x1,%bpl
jne    1396 <grd_trapezoid+0x206>
jmp    13b9 <grd_trapezoid+0x229>
movdqa 0x918(%rip),%xmm1
xor    %esi,%esi
test   $0x1,%bpl
jne    1678 <grd_trapezoid+0x4e8>
jmp    1695 <grd_trapezoid+0x505>

LLVM IR (-O0):
@.str = [39 x i8] c"grd_trapezoid: abs(scaling)=%.2f> 1 !\0A\00"
define void @grd_trapezoid(float %0, float %1, float %2, float %3, float** %4, float** %5, float** %6, float** %7, i32* %8, i32* %9) {
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float**
%16 = alloca float**
%17 = alloca float**
%18 = alloca float**
%19 = alloca i32*
%20 = alloca i32*
%21 = alloca float
%22 = alloca float
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca float
%27 = alloca i32
store float %0, float* %11
store float %1, float* %12
store float %2, float* %13
store float %3, float* %14
store float** %4, float*** %15
store float** %5, float*** %16
store float** %6, float*** %17
store float** %7, float*** %18
store i32* %8, i32** %19
store i32* %9, i32** %20
%28 = load float, float* %13
%29 = call i32 @fabs(float %28)
%30 = sitofp i32 %29 to float
%31 = load float, float* %11
%32 = load float, float* %11
%33 = fmul float %31, %32
%34 = fmul float 4.257000e+03, %33
%35 = load float, float* %12
%36 = fdiv float %34, %35
%37 = fcmp olt float %30, %36
br i1 %37, label %38, label %49
38: ; preds = %10
%39 = load float, float* %11
%40 = load float, float* %12
%41 = load float, float* %13
%42 = load float, float* %14
%43 = load float**, float*** %15
%44 = load float**, float*** %16
%45 = load float**, float*** %17
%46 = load float**, float*** %18
%47 = load i32*, i32** %19
%48 = call i32 @grd_triangle(float %39, float %40, float %41, float %42, float** %43, float** %44, float** %45, float** %46, i32* %47, i32* %27)
br label %256
49: ; preds = %10
%50 = load float, float* %11
%51 = load float, float* %12
%52 = fdiv float %50, %51
store float %52, float* %21
%53 = load float, float* %13
%54 = call i32 @fabs(float %53)
%55 = sitofp i32 %54 to float
%56 = load float, float* %11
%57 = fdiv float %55, %56
%58 = fdiv float %57, 4.257000e+03
%59 = load float, float* %21
%60 = fsub float %58, %59
store float %60, float* %22
%61 = load float, float* %21
%62 = load float, float* %14
%63 = fdiv float %61, %62
%64 = fptosi float %63 to i32
store i32 %64, i32* %23
%65 = load float, float* %22
%66 = load float, float* %14
%67 = fdiv float %65, %66
%68 = call i32 @ceil(float %67)
%69 = add nsw i32 %68, 3
store i32 %69, i32* %24
%70 = load i32, i32* %23
%71 = mul nsw i32 2, %70
%72 = load i32, i32* %24
%73 = add nsw i32 %71, %72
store i32 %73, i32* %25
%74 = load i32, i32* %25
%75 = sext i32 %74 to i64
%76 = mul i64 %75, 4
%77 = trunc i64 %76 to i32
%78 = call i64 @malloc(i32 %77)
%79 = inttoptr i64 %78 to float*
%80 = load float**, float*** %16
store float* %79, float** %80
store i32 0, i32* %27
br label %81
81: ; preds = %97, %49
%82 = load i32, i32* %27
%83 = load i32, i32* %23
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %100
85: ; preds = %81
%86 = load i32, i32* %27
%87 = sitofp i32 %86 to float
%88 = load float, float* %14
%89 = fmul float %87, %88
%90 = load float, float* %12
%91 = fmul float %89, %90
%92 = load float**, float*** %16
%93 = load float*, float** %92
%94 = load i32, i32* %27
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %93, i64 %95
store float %91, float* %96
br label %97
97: ; preds = %85
%98 = load i32, i32* %27
%99 = add nsw i32 %98, 1
store i32 %99, i32* %27
br label %81
100: ; preds = %81
%101 = load i32, i32* %23
store i32 %101, i32* %27
br label %102
102: ; preds = %121, %100
%103 = load i32, i32* %27
%104 = load i32, i32* %23
%105 = load i32, i32* %24
%106 = add nsw i32 %104, %105
%107 = icmp slt i32 %103, %106
br i1 %107, label %108, label %124
108: ; preds = %102
%109 = load float**, float*** %16
%110 = load float*, float** %109
%111 = load i32, i32* %23
%112 = sub nsw i32 %111, 1
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %110, i64 %113
%115 = load float, float* %114
%116 = load float**, float*** %16
%117 = load float*, float** %116
%118 = load i32, i32* %27
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds float, float* %117, i64 %119
store float %115, float* %120
br label %121
121: ; preds = %108
%122 = load i32, i32* %27
%123 = add nsw i32 %122, 1
store i32 %123, i32* %27
br label %102
124: ; preds = %102
store i32 0, i32* %27
br label %125
125: ; preds = %148, %124
%126 = load i32, i32* %27
%127 = load i32, i32* %23
%128 = icmp slt i32 %126, %127
br i1 %128, label %129, label %151
129: ; preds = %125
%130 = load float**, float*** %16
%131 = load float*, float** %130
%132 = load i32, i32* %23
%133 = sub nsw i32 %132, 1
%134 = load i32, i32* %27
%135 = sub nsw i32 %133, %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* %131, i64 %136
%138 = load float, float* %137
%139 = load float**, float*** %16
%140 = load float*, float** %139
%141 = load i32, i32* %23
%142 = load i32, i32* %24
%143 = add nsw i32 %141, %142
%144 = load i32, i32* %27
%145 = add nsw i32 %143, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %140, i64 %146
store float %138, float* %147
br label %148
148: ; preds = %129
%149 = load i32, i32* %27
%150 = add nsw i32 %149, 1
store i32 %150, i32* %27
br label %125
151: ; preds = %125
%152 = load float, float* %13
%153 = load float**, float*** %16
%154 = load float*, float** %153
%155 = load i32, i32* %25
%156 = call i32 @sumfloats(float* %154, i32 %155)
%157 = mul nsw i32 %156, 4257
%158 = sitofp i32 %157 to float
%159 = load float, float* %14
%160 = fmul float %158, %159
%161 = fdiv float %152, %160
store float %161, float* %26
%162 = load float, float* %26
%163 = call i32 @fabs(float %162)
%164 = icmp sgt i32 %163, 1
br i1 %164, label %165, label %168
165: ; preds = %151
%166 = load float, float* %26
%167 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), float %166)
br label %168
168: ; preds = %165, %151
%169 = load float**, float*** %16
%170 = load float*, float** %169
%171 = load i32, i32* %25
%172 = load float, float* %26
%173 = fptosi float %172 to i32
%174 = call i32 @scalefloats(float* %170, i32 %171, i32 %173)
%175 = load float**, float*** %15
%176 = icmp ne float** %175, null
br i1 %176, label %177, label %198
177: ; preds = %168
%178 = load i32, i32* %25
%179 = sext i32 %178 to i64
%180 = mul i64 %179, 4
%181 = trunc i64 %180 to i32
%182 = call i64 @malloc(i32 %181)
%183 = inttoptr i64 %182 to float*
%184 = load float**, float*** %15
store float* %183, float** %184
%185 = load float**, float*** %16
%186 = load float*, float** %185
%187 = load float**, float*** %15
%188 = load float*, float** %187
%189 = load i32, i32* %25
%190 = call i32 @cumulativeSum(float* %186, float* %188, i32 %189)
%191 = load float**, float*** %15
%192 = load float*, float** %191
%193 = load i32, i32* %25
%194 = load float, float* %14
%195 = fmul float 4.257000e+03, %194
%196 = fptosi float %195 to i32
%197 = call i32 @scalefloats(float* %192, i32 %193, i32 %196)
br label %198
198: ; preds = %177, %168
%199 = load float**, float*** %17
%200 = icmp ne float** %199, null
br i1 %200, label %201, label %222
201: ; preds = %198
%202 = load i32, i32* %25
%203 = sext i32 %202 to i64
%204 = mul i64 %203, 4
%205 = trunc i64 %204 to i32
%206 = call i64 @malloc(i32 %205)
%207 = inttoptr i64 %206 to float*
%208 = load float**, float*** %17
store float* %207, float** %208
%209 = load float**, float*** %16
%210 = load float*, float** %209
%211 = load float**, float*** %17
%212 = load float*, float** %211
%213 = load i32, i32* %25
%214 = call i32 @diffArray(float* %210, float* %212, i32 %213)
%215 = load float**, float*** %17
%216 = load float*, float** %215
%217 = load i32, i32* %25
%218 = load float, float* %14
%219 = fdiv float 1.000000e+00, %218
%220 = fptosi float %219 to i32
%221 = call i32 @scalefloats(float* %216, i32 %217, i32 %220)
br label %222
222: ; preds = %201, %198
%223 = load float**, float*** %18
%224 = icmp ne float** %223, null
br i1 %224, label %225, label %251
225: ; preds = %222
%226 = load i32, i32* %25
%227 = sext i32 %226 to i64
%228 = mul i64 %227, 4
%229 = trunc i64 %228 to i32
%230 = call i64 @malloc(i32 %229)
%231 = inttoptr i64 %230 to float*
%232 = load float**, float*** %18
store float* %231, float** %232
store i32 0, i32* %27
br label %233
233: ; preds = %247, %225
%234 = load i32, i32* %27
%235 = load i32, i32* %25
%236 = icmp slt i32 %234, %235
br i1 %236, label %237, label %250
237: ; preds = %233
%238 = load i32, i32* %27
%239 = sitofp i32 %238 to float
%240 = load float, float* %14
%241 = fmul float %239, %240
%242 = load float**, float*** %18
%243 = load float*, float** %242
%244 = load i32, i32* %27
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float, float* %243, i64 %245
store float %241, float* %246
br label %247
247: ; preds = %237
%248 = load i32, i32* %27
%249 = add nsw i32 %248, 1
store i32 %249, i32* %27
br label %233
250: ; preds = %233
br label %251
251: ; preds = %250, %222
%252 = load i32, i32* %25
%253 = load i32*, i32** %19
store i32 %252, i32* %253
%254 = load i32, i32* %23
%255 = load i32*, i32** %20
store i32 %254, i32* %255
br label %256
256: ; preds = %251, %38
ret void
}

LLVM IR (-O2):
@.str = [39 x i8] c"grd_trapezoid: abs(scaling)=%.2f> 1 !\0A\00"
define void @grd_trapezoid(float %0, float %1, float %2, float %3, float** %4, float** %5, float** %6, float** %7, i32* %8, i32* nocapture writeonly %9) {
%11 = alloca i32
%12 = bitcast i32* %11 to i8*
%13 = tail call i32 @fabs(float %2)
%14 = sitofp i32 %13 to float
%15 = fmul float %0, %0
%16 = fmul float %15, 4.257000e+03
%17 = fdiv float %16, %1
%18 = fcmp ogt float %17, %14
br i1 %18, label %19, label %21
19: ; preds = %10
%20 = call i32 @grd_triangle(float %0, float %1, float %2, float %3, float** %4, float** %5, float** %6, float** %7, i32* %8, i32* %11)
br label %291
21: ; preds = %10
%22 = fdiv float %0, %1
%23 = tail call i32 @fabs(float %2)
%24 = sitofp i32 %23 to float
%25 = fdiv float %24, %0
%26 = fdiv float %25, 4.257000e+03
%27 = fsub float %26, %22
%28 = fdiv float %22, %3
%29 = fptosi float %28 to i32
%30 = fdiv float %27, %3
%31 = tail call i32 @ceil(float %30)
%32 = add nsw i32 %31, 3
%33 = shl nsw i32 %29, 1
%34 = add nsw i32 %32, %33
%35 = shl i32 %34, 2
%36 = tail call i64 @malloc(i32 %35)
%37 = inttoptr i64 %36 to float*
store float* %37, float** %5
%38 = icmp sgt i32 %29, 0
br i1 %38, label %39, label %111
39: ; preds = %21
%40 = zext i32 %29 to i64
%41 = icmp ult i32 %29, 8
br i1 %41, label %109, label %42
42: ; preds = %39
%43 = and i64 %40, 4294967288
%44 = insertelement <4 x float> poison, float %3, i64 0
%45 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%46 = insertelement <4 x float> poison, float %3, i64 0
%47 = shufflevector <4 x float> %46, <4 x float> poison, <4 x i32> zeroinitializer
%48 = insertelement <4 x float> poison, float %1, i64 0
%49 = shufflevector <4 x float> %48, <4 x float> poison, <4 x i32> zeroinitializer
%50 = insertelement <4 x float> poison, float %1, i64 0
%51 = shufflevector <4 x float> %50, <4 x float> poison, <4 x i32> zeroinitializer
%52 = add nsw i64 %43, -8
%53 = lshr exact i64 %52, 3
%54 = add nuw nsw i64 %53, 1
%55 = and i64 %54, 1
%56 = icmp eq i64 %52, 0
br i1 %56, label %91, label %57
57: ; preds = %42
%58 = and i64 %54, 4611686018427387902
br label %59
59: ; preds = %59, %57
%60 = phi i64 [ 0, %57 ], [ %87, %59 ]
%61 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %57 ], [ %88, %59 ]
%62 = phi i64 [ 0, %57 ], [ %89, %59 ]
%63 = add <4 x i32> %61, <i32 4, i32 4, i32 4, i32 4>
%64 = sitofp <4 x i32> %61 to <4 x float>
%65 = sitofp <4 x i32> %63 to <4 x float>
%66 = fmul <4 x float> %45, %64
%67 = fmul <4 x float> %47, %65
%68 = fmul <4 x float> %66, %49
%69 = fmul <4 x float> %67, %51
%70 = getelementptr inbounds float, float* %37, i64 %60
%71 = bitcast float* %70 to <4 x float>*
store <4 x float> %68, <4 x float>* %71
%72 = getelementptr inbounds float, float* %70, i64 4
%73 = bitcast float* %72 to <4 x float>*
store <4 x float> %69, <4 x float>* %73
%74 = or i64 %60, 8
%75 = add <4 x i32> %61, <i32 8, i32 8, i32 8, i32 8>
%76 = add <4 x i32> %61, <i32 12, i32 12, i32 12, i32 12>
%77 = sitofp <4 x i32> %75 to <4 x float>
%78 = sitofp <4 x i32> %76 to <4 x float>
%79 = fmul <4 x float> %45, %77
%80 = fmul <4 x float> %47, %78
%81 = fmul <4 x float> %79, %49
%82 = fmul <4 x float> %80, %51
%83 = getelementptr inbounds float, float* %37, i64 %74
%84 = bitcast float* %83 to <4 x float>*
store <4 x float> %81, <4 x float>* %84
%85 = getelementptr inbounds float, float* %83, i64 4
%86 = bitcast float* %85 to <4 x float>*
store <4 x float> %82, <4 x float>* %86
%87 = add nuw i64 %60, 16
%88 = add <4 x i32> %61, <i32 16, i32 16, i32 16, i32 16>
%89 = add i64 %62, 2
%90 = icmp eq i64 %89, %58
br i1 %90, label %91, label %59
91: ; preds = %59, %42
%92 = phi i64 [ 0, %42 ], [ %87, %59 ]
%93 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %42 ], [ %88, %59 ]
%94 = icmp eq i64 %55, 0
br i1 %94, label %107, label %95
95: ; preds = %91
%96 = add <4 x i32> %93, <i32 4, i32 4, i32 4, i32 4>
%97 = sitofp <4 x i32> %93 to <4 x float>
%98 = sitofp <4 x i32> %96 to <4 x float>
%99 = fmul <4 x float> %45, %97
%100 = fmul <4 x float> %47, %98
%101 = fmul <4 x float> %99, %49
%102 = fmul <4 x float> %100, %51
%103 = getelementptr inbounds float, float* %37, i64 %92
%104 = bitcast float* %103 to <4 x float>*
store <4 x float> %101, <4 x float>* %104
%105 = getelementptr inbounds float, float* %103, i64 4
%106 = bitcast float* %105 to <4 x float>*
store <4 x float> %102, <4 x float>* %106
br label %107
107: ; preds = %91, %95
%108 = icmp eq i64 %43, %40
br i1 %108, label %111, label %109
109: ; preds = %39, %107
%110 = phi i64 [ 0, %39 ], [ %43, %107 ]
br label %120
111: ; preds = %120, %107, %21
%112 = add nsw i32 %32, %29
%113 = icmp sgt i32 %31, -3
br i1 %113, label %114, label %129
114: ; preds = %111
%115 = add nsw i32 %29, -1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %37, i64 %116
%118 = sext i32 %29 to i64
%119 = sext i32 %112 to i64
br label %137
120: ; preds = %109, %120
%121 = phi i64 [ %127, %120 ], [ %110, %109 ]
%122 = trunc i64 %121 to i32
%123 = sitofp i32 %122 to float
%124 = fmul float %123, %3
%125 = fmul float %124, %1
%126 = getelementptr inbounds float, float* %37, i64 %121
store float %125, float* %126
%127 = add nuw nsw i64 %121, 1
%128 = icmp eq i64 %127, %40
br i1 %128, label %111, label %120
129: ; preds = %137, %111
br i1 %38, label %130, label %178
130: ; preds = %129
%131 = sext i32 %112 to i64
%132 = zext i32 %29 to i64
%133 = and i64 %132, 1
%134 = icmp eq i32 %29, 1
br i1 %134, label %166, label %135
135: ; preds = %130
%136 = and i64 %132, 4294967294
br label %143
137: ; preds = %114, %137
%138 = phi i64 [ %118, %114 ], [ %141, %137 ]
%139 = load float, float* %117
%140 = getelementptr inbounds float, float* %37, i64 %138
store float %139, float* %140
%141 = add nsw i64 %138, 1
%142 = icmp slt i64 %141, %119
br i1 %142, label %137, label %129
143: ; preds = %143, %135
%144 = phi i64 [ 0, %135 ], [ %163, %143 ]
%145 = phi i64 [ 0, %135 ], [ %164, %143 ]
%146 = trunc i64 %144 to i32
%147 = xor i32 %146, -1
%148 = add i32 %147, %29
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* %37, i64 %149
%151 = load float, float* %150
%152 = add nsw i64 %144, %131
%153 = getelementptr inbounds float, float* %37, i64 %152
store float %151, float* %153
%154 = or i64 %144, 1
%155 = trunc i64 %154 to i32
%156 = xor i32 %155, -1
%157 = add i32 %156, %29
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds float, float* %37, i64 %158
%160 = load float, float* %159
%161 = add nsw i64 %154, %131
%162 = getelementptr inbounds float, float* %37, i64 %161
store float %160, float* %162
%163 = add nuw nsw i64 %144, 2
%164 = add i64 %145, 2
%165 = icmp eq i64 %164, %136
br i1 %165, label %166, label %143
166: ; preds = %143, %130
%167 = phi i64 [ 0, %130 ], [ %163, %143 ]
%168 = icmp eq i64 %133, 0
br i1 %168, label %178, label %169
169: ; preds = %166
%170 = trunc i64 %167 to i32
%171 = xor i32 %170, -1
%172 = add i32 %171, %29
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %37, i64 %173
%175 = load float, float* %174
%176 = add nsw i64 %167, %131
%177 = getelementptr inbounds float, float* %37, i64 %176
store float %175, float* %177
br label %178
178: ; preds = %169, %166, %129
%179 = phi i32 [ 0, %129 ], [ %29, %166 ], [ %29, %169 ]
store i32 %179, i32* %11
%180 = tail call i32 @sumfloats(float* %37, i32 %34)
%181 = mul nsw i32 %180, 4257
%182 = sitofp i32 %181 to float
%183 = fmul float %182, %3
%184 = fdiv float %2, %183
%185 = tail call i32 @fabs(float %184)
%186 = icmp sgt i32 %185, 1
br i1 %186, label %187, label %189
187: ; preds = %178
%188 = tail call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), float %184)
br label %189
189: ; preds = %187, %178
%190 = load float*, float** %5
%191 = fptosi float %184 to i32
%192 = tail call i32 @scalefloats(float* %190, i32 %34, i32 %191)
%193 = icmp eq float** %4, null
br i1 %193, label %203, label %194
194: ; preds = %189
%195 = tail call i64 @malloc(i32 %35)
%196 = inttoptr i64 %195 to float*
store float* %196, float** %4
%197 = load float*, float** %5
%198 = tail call i32 @cumulativeSum(float* %197, float* %196, i32 %34)
%199 = load float*, float** %4
%200 = fmul float %3, 4.257000e+03
%201 = fptosi float %200 to i32
%202 = tail call i32 @scalefloats(float* %199, i32 %34, i32 %201)
br label %203
203: ; preds = %194, %189
%204 = icmp eq float** %6, null
br i1 %204, label %214, label %205
205: ; preds = %203
%206 = tail call i64 @malloc(i32 %35)
%207 = inttoptr i64 %206 to float*
store float* %207, float** %6
%208 = load float*, float** %5
%209 = tail call i32 @diffArray(float* %208, float* %207, i32 %34)
%210 = load float*, float** %6
%211 = fdiv float 1.000000e+00, %3
%212 = fptosi float %211 to i32
%213 = tail call i32 @scalefloats(float* %210, i32 %34, i32 %212)
br label %214
214: ; preds = %205, %203
%215 = icmp eq float** %7, null
br i1 %215, label %290, label %216
216: ; preds = %214
%217 = tail call i64 @malloc(i32 %35)
%218 = inttoptr i64 %217 to float*
store float* %218, float** %7
%219 = icmp sgt i32 %34, 0
br i1 %219, label %220, label %290
220: ; preds = %216
%221 = zext i32 %34 to i64
%222 = icmp ult i32 %34, 8
br i1 %222, label %280, label %223
223: ; preds = %220
%224 = and i64 %221, 4294967288
%225 = insertelement <4 x float> poison, float %3, i64 0
%226 = shufflevector <4 x float> %225, <4 x float> poison, <4 x i32> zeroinitializer
%227 = insertelement <4 x float> poison, float %3, i64 0
%228 = shufflevector <4 x float> %227, <4 x float> poison, <4 x i32> zeroinitializer
%229 = add nsw i64 %224, -8
%230 = lshr exact i64 %229, 3
%231 = add nuw nsw i64 %230, 1
%232 = and i64 %231, 1
%233 = icmp eq i64 %229, 0
br i1 %233, label %264, label %234
234: ; preds = %223
%235 = and i64 %231, 4611686018427387902
br label %236
236: ; preds = %236, %234
%237 = phi i64 [ 0, %234 ], [ %260, %236 ]
%238 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %234 ], [ %261, %236 ]
%239 = phi i64 [ 0, %234 ], [ %262, %236 ]
%240 = add <4 x i32> %238, <i32 4, i32 4, i32 4, i32 4>
%241 = sitofp <4 x i32> %238 to <4 x float>
%242 = sitofp <4 x i32> %240 to <4 x float>
%243 = fmul <4 x float> %226, %241
%244 = fmul <4 x float> %228, %242
%245 = getelementptr inbounds float, float* %218, i64 %237
%246 = bitcast float* %245 to <4 x float>*
store <4 x float> %243, <4 x float>* %246
%247 = getelementptr inbounds float, float* %245, i64 4
%248 = bitcast float* %247 to <4 x float>*
store <4 x float> %244, <4 x float>* %248
%249 = or i64 %237, 8
%250 = add <4 x i32> %238, <i32 8, i32 8, i32 8, i32 8>
%251 = add <4 x i32> %238, <i32 12, i32 12, i32 12, i32 12>
%252 = sitofp <4 x i32> %250 to <4 x float>
%253 = sitofp <4 x i32> %251 to <4 x float>
%254 = fmul <4 x float> %226, %252
%255 = fmul <4 x float> %228, %253
%256 = getelementptr inbounds float, float* %218, i64 %249
%257 = bitcast float* %256 to <4 x float>*
store <4 x float> %254, <4 x float>* %257
%258 = getelementptr inbounds float, float* %256, i64 4
%259 = bitcast float* %258 to <4 x float>*
store <4 x float> %255, <4 x float>* %259
%260 = add nuw i64 %237, 16
%261 = add <4 x i32> %238, <i32 16, i32 16, i32 16, i32 16>
%262 = add i64 %239, 2
%263 = icmp eq i64 %262, %235
br i1 %263, label %264, label %236
264: ; preds = %236, %223
%265 = phi i64 [ 0, %223 ], [ %260, %236 ]
%266 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %223 ], [ %261, %236 ]
%267 = icmp eq i64 %232, 0
br i1 %267, label %278, label %268
268: ; preds = %264
%269 = add <4 x i32> %266, <i32 4, i32 4, i32 4, i32 4>
%270 = sitofp <4 x i32> %266 to <4 x float>
%271 = sitofp <4 x i32> %269 to <4 x float>
%272 = fmul <4 x float> %226, %270
%273 = fmul <4 x float> %228, %271
%274 = getelementptr inbounds float, float* %218, i64 %265
%275 = bitcast float* %274 to <4 x float>*
store <4 x float> %272, <4 x float>* %275
%276 = getelementptr inbounds float, float* %274, i64 4
%277 = bitcast float* %276 to <4 x float>*
store <4 x float> %273, <4 x float>* %277
br label %278
278: ; preds = %264, %268
%279 = icmp eq i64 %224, %221
br i1 %279, label %290, label %280
280: ; preds = %220, %278
%281 = phi i64 [ 0, %220 ], [ %224, %278 ]
br label %282
282: ; preds = %280, %282
%283 = phi i64 [ %288, %282 ], [ %281, %280 ]
%284 = trunc i64 %283 to i32
%285 = sitofp i32 %284 to float
%286 = fmul float %285, %3
%287 = getelementptr inbounds float, float* %218, i64 %283
store float %286, float* %287
%288 = add nuw nsw i64 %283, 1
%289 = icmp eq i64 %288, %221
br i1 %289, label %290, label %282
290: ; preds = %282, %278, %216, %214
store i32 %34, i32* %8
store i32 %29, i32* %9
br label %291
291: ; preds = %290, %19
ret void
}