#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);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scalefloats(float *, int, float);
void grd_rampup(float GMAX, float SMAX, float Gtgt, float Ts, float **kx,
                float **gx, float **slew, float **time, int *N) {
  float T_ramp;
  int N_ramp;
  float scaling;
  int n;
  if (Gtgt > 1.001 * GMAX)
    printf("grd_rampup: Gtgt > 1.001*GMAX\n");
  T_ramp = Gtgt / SMAX;
  N_ramp = ceil(T_ramp / Ts) + 1;
  *gx = (float *)malloc(N_ramp * sizeof(float));
  for (n = 0; n < N_ramp; n++)
    (*gx)[n] = n * Ts * SMAX;
  scaling = (Gtgt / (*gx)[N_ramp - 1]);
  if (fabs(scaling) > 1)
    printf("grd_rampup: abs(scaling)=%.2f> 1 !\n", scaling);
  scalefloats(*gx, N_ramp, scaling);
  if (kx) {
    *kx = (float *)malloc(N_ramp * sizeof(float));
    cumulativeSum(*gx, *kx, N_ramp);
    scalefloats(*kx, N_ramp, 4257 * Ts);
  }
  if (slew) {
    *slew = (float *)malloc(N_ramp * sizeof(float));
    diffArray(*gx, *slew, N_ramp);
    scalefloats(*slew, N_ramp, 1.0f / Ts);
  }
  if (time) {
    *time = (float *)malloc(N_ramp * sizeof(float));
    for (n = 0; n < N_ramp; n++)
      (*time)[n] = n * Ts;
  }
  *N = N_ramp;
  return;
}


x86 assembly (clang, -O0):
<grd_rampup>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%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)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x4(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xe46(%rip),%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    11d6 <grd_rampup+0x66>
lea    0xe41(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movss  -0xc(%rbp),%xmm0
divss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
divss  -0x10(%rbp),%xmm0
call   1040 <ceil@plt>
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1253 <grd_rampup+0xe3>
cvtsi2ssl -0x48(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    121a <grd_rampup+0xaa>
movss  -0xc(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
call   1060 <fabs@plt>
cmp    $0x1,%eax
jle    129c <grd_rampup+0x12c>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd9a(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x40(%rbp),%esi
movss  -0x44(%rbp),%xmm0
call   1030 <scalefloats@plt>
cmpq   $0x0,-0x18(%rbp)
je     1306 <grd_rampup+0x196>
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <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    -0x40(%rbp),%edx
call   1090 <cumulativeSum@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x40(%rbp),%esi
movss  0xd0c(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
call   1030 <scalefloats@plt>
cmpq   $0x0,-0x28(%rbp)
je     135c <grd_rampup+0x1ec>
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <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    -0x40(%rbp),%edx
call   1070 <diffArray@plt>
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
mov    -0x40(%rbp),%esi
movss  0xcba(%rip),%xmm0
divss  -0x10(%rbp),%xmm0
call   1030 <scalefloats@plt>
cmpq   $0x0,-0x30(%rbp)
je     13c0 <grd_rampup+0x250>
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    13bb <grd_rampup+0x24b>
cvtsi2ssl -0x48(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1387 <grd_rampup+0x217>
jmp    13c0 <grd_rampup+0x250>
mov    -0x40(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<grd_rampup>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8,0x38(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,0x28(%rsp)
mov    %rsi,%r13
mov    %rdi,%rbp
cvtss2sd %xmm2,%xmm4
cvtss2sd %xmm0,%xmm0
mulsd  0xe4d(%rip),%xmm0
ucomisd %xmm0,%xmm4
movaps %xmm3,0x10(%rsp)
movss  %xmm2,0xc(%rsp)
movaps %xmm1,0x40(%rsp)
jbe    11e5 <grd_rampup+0x65>
lea    0xebc(%rip),%rdi
call   1030 <puts@plt>
movaps 0x40(%rsp),%xmm1
movss  0xc(%rsp),%xmm2
movaps 0x10(%rsp),%xmm3
movaps %xmm2,%xmm0
divss  %xmm1,%xmm0
divss  %xmm3,%xmm0
call   1050 <ceil@plt>
mov    %eax,%ebx
lea    0x1(%rbx),%r15d
lea    0x4(,%rbx,4),%r14d
mov    %r14d,%edi
call   1090 <malloc@plt>
movaps 0x40(%rsp),%xmm5
movaps 0x10(%rsp),%xmm4
mov    %rax,0x0(%r13)
mov    %r15d,%r12d
test   %ebx,%ebx
js     134d <grd_rampup+0x1cd>
cmp    $0x8,%r15d
jae    1231 <grd_rampup+0xb1>
xor    %ecx,%ecx
jmp    1330 <grd_rampup+0x1b0>
mov    %r12d,%ecx
and    $0xfffffff8,%ecx
movaps %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm1
movaps %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm0
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1550 <grd_rampup+0x3d0>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xda4(%rip),%xmm2
xor    %edx,%edx
movdqa 0xda9(%rip),%xmm8
movdqa 0xdb0(%rip),%xmm9
movdqa 0xdb7(%rip),%xmm10
movdqa 0xdbf(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
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,%rdx,4)
movups %xmm7,0x10(%rax,%rdx,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,%rdx,4)
movups %xmm7,0x30(%rax,%rdx,4)
add    $0x10,%rdx
paddd  %xmm6,%xmm2
add    $0xfffffffffffffffe,%rdi
jne    12a0 <grd_rampup+0x120>
test   $0x1,%sil
je     1329 <grd_rampup+0x1a9>
cvtdq2ps %xmm2,%xmm3
paddd  0xd0f(%rip),%xmm2
cvtdq2ps %xmm2,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm2
movups %xmm3,(%rax,%rdx,4)
movups %xmm2,0x10(%rax,%rdx,4)
cmp    %r12,%rcx
je     134d <grd_rampup+0x1cd>
xchg   %ax,%ax
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm4,%xmm0
mulss  %xmm5,%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1330 <grd_rampup+0x1b0>
movslq %ebx,%rcx
movss  0xc(%rsp),%xmm0
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsp)
call   1070 <fabs@plt>
cmp    $0x2,%eax
jl     1383 <grd_rampup+0x203>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcec(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x0(%r13),%rdi
mov    %r15d,%esi
movss  0xc(%rsp),%xmm0
call   1040 <scalefloats@plt>
test   %rbp,%rbp
je     13cf <grd_rampup+0x24f>
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,0x0(%rbp)
mov    0x0(%r13),%rdi
mov    %rax,%rsi
mov    %r15d,%edx
call   10a0 <cumulativeSum@plt>
mov    0x0(%rbp),%rdi
movss  0xc9f(%rip),%xmm0
mulss  0x10(%rsp),%xmm0
mov    %r15d,%esi
call   1040 <scalefloats@plt>
mov    0x28(%rsp),%rbp
test   %rbp,%rbp
je     140e <grd_rampup+0x28e>
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,0x0(%rbp)
mov    0x0(%r13),%rdi
mov    %rax,%rsi
mov    %r15d,%edx
call   1080 <diffArray@plt>
mov    0x0(%rbp),%rdi
movss  0xc64(%rip),%xmm0
divss  0x10(%rsp),%xmm0
mov    %r15d,%esi
call   1040 <scalefloats@plt>
mov    0x30(%rsp),%rbp
test   %rbp,%rbp
je     1539 <grd_rampup+0x3b9>
mov    %r14d,%edi
call   1090 <malloc@plt>
movaps 0x10(%rsp),%xmm2
mov    %rax,0x0(%rbp)
test   %ebx,%ebx
js     1539 <grd_rampup+0x3b9>
cmp    $0x8,%r15d
jae    1442 <grd_rampup+0x2c2>
xor    %ecx,%ecx
jmp    1520 <grd_rampup+0x3a0>
mov    %r12d,%ecx
and    $0xfffffff8,%ecx
movaps %xmm2,%xmm0
shufps $0x0,%xmm2,%xmm0
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1569 <grd_rampup+0x3e9>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xb9a(%rip),%xmm1
xor    %edx,%edx
movdqa 0xb9f(%rip),%xmm8
movdqa 0xba7(%rip),%xmm3
movdqa 0xbaf(%rip),%xmm4
movdqa 0xbb7(%rip),%xmm5
nopl   0x0(%rax)
movdqa %xmm1,%xmm6
paddd  %xmm8,%xmm6
cvtdq2ps %xmm1,%xmm7
cvtdq2ps %xmm6,%xmm6
mulps  %xmm0,%xmm7
mulps  %xmm0,%xmm6
movups %xmm7,(%rax,%rdx,4)
movups %xmm6,0x10(%rax,%rdx,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,%rdx,4)
movups %xmm7,0x30(%rax,%rdx,4)
add    $0x10,%rdx
paddd  %xmm5,%xmm1
add    $0xfffffffffffffffe,%rdi
jne    14a0 <grd_rampup+0x320>
test   $0x1,%sil
je     1515 <grd_rampup+0x395>
cvtdq2ps %xmm1,%xmm3
paddd  0xb1d(%rip),%xmm1
cvtdq2ps %xmm1,%xmm1
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm1
movups %xmm3,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
cmp    %r12,%rcx
je     1539 <grd_rampup+0x3b9>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm2,%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1520 <grd_rampup+0x3a0>
mov    0x38(%rsp),%rax
mov    %r15d,(%rax)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movdqa 0xab8(%rip),%xmm2
xor    %edx,%edx
test   $0x1,%sil
jne    1306 <grd_rampup+0x186>
jmp    1329 <grd_rampup+0x1a9>
movdqa 0xa9f(%rip),%xmm1
xor    %edx,%edx
test   $0x1,%sil
jne    14f8 <grd_rampup+0x378>
jmp    1515 <grd_rampup+0x395>

LLVM IR (-O0):
@.str = [31 x i8] c"grd_rampup: Gtgt > 1.001*GMAX\0A\00"
@.str.1 = [36 x i8] c"grd_rampup: abs(scaling)=%.2f> 1 !\0A\00"
define void @grd_rampup(float %0, float %1, float %2, float %3, float** %4, float** %5, float** %6, float** %7, i32* %8) {
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float**
%15 = alloca float**
%16 = alloca float**
%17 = alloca float**
%18 = alloca i32*
%19 = alloca float
%20 = alloca i32
%21 = alloca float
%22 = alloca i32
store float %0, float* %10
store float %1, float* %11
store float %2, float* %12
store float %3, float* %13
store float** %4, float*** %14
store float** %5, float*** %15
store float** %6, float*** %16
store float** %7, float*** %17
store i32* %8, i32** %18
%23 = load float, float* %12
%24 = fpext float %23 to double
%25 = load float, float* %10
%26 = fpext float %25 to double
%27 = fmul double 1.001000e+00, %26
%28 = fcmp ogt double %24, %27
br i1 %28, label %29, label %31
29: ; preds = %9
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
br label %31
31: ; preds = %29, %9
%32 = load float, float* %12
%33 = load float, float* %11
%34 = fdiv float %32, %33
store float %34, float* %19
%35 = load float, float* %19
%36 = load float, float* %13
%37 = fdiv float %35, %36
%38 = call i32 @ceil(float %37)
%39 = add nsw i32 %38, 1
store i32 %39, i32* %20
%40 = load i32, i32* %20
%41 = sext i32 %40 to i64
%42 = mul i64 %41, 4
%43 = trunc i64 %42 to i32
%44 = call i64 @malloc(i32 %43)
%45 = inttoptr i64 %44 to float*
%46 = load float**, float*** %15
store float* %45, float** %46
store i32 0, i32* %22
br label %47
47: ; preds = %63, %31
%48 = load i32, i32* %22
%49 = load i32, i32* %20
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %66
51: ; preds = %47
%52 = load i32, i32* %22
%53 = sitofp i32 %52 to float
%54 = load float, float* %13
%55 = fmul float %53, %54
%56 = load float, float* %11
%57 = fmul float %55, %56
%58 = load float**, float*** %15
%59 = load float*, float** %58
%60 = load i32, i32* %22
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
store float %57, float* %62
br label %63
63: ; preds = %51
%64 = load i32, i32* %22
%65 = add nsw i32 %64, 1
store i32 %65, i32* %22
br label %47
66: ; preds = %47
%67 = load float, float* %12
%68 = load float**, float*** %15
%69 = load float*, float** %68
%70 = load i32, i32* %20
%71 = sub nsw i32 %70, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %69, i64 %72
%74 = load float, float* %73
%75 = fdiv float %67, %74
store float %75, float* %21
%76 = load float, float* %21
%77 = call i32 @fabs(float %76)
%78 = icmp sgt i32 %77, 1
br i1 %78, label %79, label %83
79: ; preds = %66
%80 = load float, float* %21
%81 = fpext float %80 to double
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0), double %81)
br label %83
83: ; preds = %79, %66
%84 = load float**, float*** %15
%85 = load float*, float** %84
%86 = load i32, i32* %20
%87 = load float, float* %21
%88 = call i32 @scalefloats(float* %85, i32 %86, float %87)
%89 = load float**, float*** %14
%90 = icmp ne float** %89, null
br i1 %90, label %91, label %111
91: ; preds = %83
%92 = load i32, i32* %20
%93 = sext i32 %92 to i64
%94 = mul i64 %93, 4
%95 = trunc i64 %94 to i32
%96 = call i64 @malloc(i32 %95)
%97 = inttoptr i64 %96 to float*
%98 = load float**, float*** %14
store float* %97, float** %98
%99 = load float**, float*** %15
%100 = load float*, float** %99
%101 = load float**, float*** %14
%102 = load float*, float** %101
%103 = load i32, i32* %20
%104 = call i32 @cumulativeSum(float* %100, float* %102, i32 %103)
%105 = load float**, float*** %14
%106 = load float*, float** %105
%107 = load i32, i32* %20
%108 = load float, float* %13
%109 = fmul float 4.257000e+03, %108
%110 = call i32 @scalefloats(float* %106, i32 %107, float %109)
br label %111
111: ; preds = %91, %83
%112 = load float**, float*** %16
%113 = icmp ne float** %112, null
br i1 %113, label %114, label %134
114: ; preds = %111
%115 = load i32, i32* %20
%116 = sext i32 %115 to i64
%117 = mul i64 %116, 4
%118 = trunc i64 %117 to i32
%119 = call i64 @malloc(i32 %118)
%120 = inttoptr i64 %119 to float*
%121 = load float**, float*** %16
store float* %120, float** %121
%122 = load float**, float*** %15
%123 = load float*, float** %122
%124 = load float**, float*** %16
%125 = load float*, float** %124
%126 = load i32, i32* %20
%127 = call i32 @diffArray(float* %123, float* %125, i32 %126)
%128 = load float**, float*** %16
%129 = load float*, float** %128
%130 = load i32, i32* %20
%131 = load float, float* %13
%132 = fdiv float 1.000000e+00, %131
%133 = call i32 @scalefloats(float* %129, i32 %130, float %132)
br label %134
134: ; preds = %114, %111
%135 = load float**, float*** %17
%136 = icmp ne float** %135, null
br i1 %136, label %137, label %163
137: ; preds = %134
%138 = load i32, i32* %20
%139 = sext i32 %138 to i64
%140 = mul i64 %139, 4
%141 = trunc i64 %140 to i32
%142 = call i64 @malloc(i32 %141)
%143 = inttoptr i64 %142 to float*
%144 = load float**, float*** %17
store float* %143, float** %144
store i32 0, i32* %22
br label %145
145: ; preds = %159, %137
%146 = load i32, i32* %22
%147 = load i32, i32* %20
%148 = icmp slt i32 %146, %147
br i1 %148, label %149, label %162
149: ; preds = %145
%150 = load i32, i32* %22
%151 = sitofp i32 %150 to float
%152 = load float, float* %13
%153 = fmul float %151, %152
%154 = load float**, float*** %17
%155 = load float*, float** %154
%156 = load i32, i32* %22
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %155, i64 %157
store float %153, float* %158
br label %159
159: ; preds = %149
%160 = load i32, i32* %22
%161 = add nsw i32 %160, 1
store i32 %161, i32* %22
br label %145
162: ; preds = %145
br label %163
163: ; preds = %162, %134
%164 = load i32, i32* %20
%165 = load i32*, i32** %18
store i32 %164, i32* %165
ret void
}

LLVM IR (-O2):
@.str.1 = [36 x i8] c"grd_rampup: abs(scaling)=%.2f> 1 !\0A\00"
@str = [30 x i8] c"grd_rampup: Gtgt > 1.001*GMAX\00"
define void @grd_rampup(float %0, float %1, float %2, float %3, float** %4, float** nocapture %5, float** %6, float** %7, i32* nocapture writeonly %8) {
%10 = fpext float %2 to double
%11 = fpext float %0 to double
%12 = fmul double %11, 1.001000e+00
%13 = fcmp olt double %12, %10
br i1 %13, label %14, label %16
14: ; preds = %9
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0))
br label %16
16: ; preds = %14, %9
%17 = fdiv float %2, %1
%18 = fdiv float %17, %3
%19 = tail call i32 @ceil(float %18)
%20 = add i32 %19, 1
%21 = shl i32 %20, 2
%22 = tail call i64 @malloc(i32 %21)
%23 = inttoptr i64 %22 to float*
store float* %23, float** %5
%24 = icmp slt i32 %19, 0
br i1 %24, label %106, label %25
25: ; preds = %16
%26 = zext i32 %20 to i64
%27 = icmp ult i32 %20, 8
br i1 %27, label %95, label %28
28: ; preds = %25
%29 = and i64 %26, 4294967288
%30 = insertelement <4 x float> poison, float %3, i64 0
%31 = shufflevector <4 x float> %30, <4 x float> poison, <4 x i32> zeroinitializer
%32 = insertelement <4 x float> poison, float %3, i64 0
%33 = shufflevector <4 x float> %32, <4 x float> poison, <4 x i32> zeroinitializer
%34 = insertelement <4 x float> poison, float %1, i64 0
%35 = shufflevector <4 x float> %34, <4 x float> poison, <4 x i32> zeroinitializer
%36 = insertelement <4 x float> poison, float %1, i64 0
%37 = shufflevector <4 x float> %36, <4 x float> poison, <4 x i32> zeroinitializer
%38 = add nsw i64 %29, -8
%39 = lshr exact i64 %38, 3
%40 = add nuw nsw i64 %39, 1
%41 = and i64 %40, 1
%42 = icmp eq i64 %38, 0
br i1 %42, label %77, label %43
43: ; preds = %28
%44 = and i64 %40, 4611686018427387902
br label %45
45: ; preds = %45, %43
%46 = phi i64 [ 0, %43 ], [ %73, %45 ]
%47 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %43 ], [ %74, %45 ]
%48 = phi i64 [ 0, %43 ], [ %75, %45 ]
%49 = add <4 x i32> %47, <i32 4, i32 4, i32 4, i32 4>
%50 = sitofp <4 x i32> %47 to <4 x float>
%51 = sitofp <4 x i32> %49 to <4 x float>
%52 = fmul <4 x float> %31, %50
%53 = fmul <4 x float> %33, %51
%54 = fmul <4 x float> %52, %35
%55 = fmul <4 x float> %53, %37
%56 = getelementptr inbounds float, float* %23, i64 %46
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %54, <4 x float>* %57
%58 = getelementptr inbounds float, float* %56, i64 4
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %55, <4 x float>* %59
%60 = or i64 %46, 8
%61 = add <4 x i32> %47, <i32 8, i32 8, i32 8, i32 8>
%62 = add <4 x i32> %47, <i32 12, i32 12, i32 12, i32 12>
%63 = sitofp <4 x i32> %61 to <4 x float>
%64 = sitofp <4 x i32> %62 to <4 x float>
%65 = fmul <4 x float> %31, %63
%66 = fmul <4 x float> %33, %64
%67 = fmul <4 x float> %65, %35
%68 = fmul <4 x float> %66, %37
%69 = getelementptr inbounds float, float* %23, i64 %60
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %67, <4 x float>* %70
%71 = getelementptr inbounds float, float* %69, i64 4
%72 = bitcast float* %71 to <4 x float>*
store <4 x float> %68, <4 x float>* %72
%73 = add nuw i64 %46, 16
%74 = add <4 x i32> %47, <i32 16, i32 16, i32 16, i32 16>
%75 = add i64 %48, 2
%76 = icmp eq i64 %75, %44
br i1 %76, label %77, label %45
77: ; preds = %45, %28
%78 = phi i64 [ 0, %28 ], [ %73, %45 ]
%79 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %28 ], [ %74, %45 ]
%80 = icmp eq i64 %41, 0
br i1 %80, label %93, label %81
81: ; preds = %77
%82 = add <4 x i32> %79, <i32 4, i32 4, i32 4, i32 4>
%83 = sitofp <4 x i32> %79 to <4 x float>
%84 = sitofp <4 x i32> %82 to <4 x float>
%85 = fmul <4 x float> %31, %83
%86 = fmul <4 x float> %33, %84
%87 = fmul <4 x float> %85, %35
%88 = fmul <4 x float> %86, %37
%89 = getelementptr inbounds float, float* %23, i64 %78
%90 = bitcast float* %89 to <4 x float>*
store <4 x float> %87, <4 x float>* %90
%91 = getelementptr inbounds float, float* %89, i64 4
%92 = bitcast float* %91 to <4 x float>*
store <4 x float> %88, <4 x float>* %92
br label %93
93: ; preds = %77, %81
%94 = icmp eq i64 %29, %26
br i1 %94, label %106, label %95
95: ; preds = %25, %93
%96 = phi i64 [ 0, %25 ], [ %29, %93 ]
br label %97
97: ; preds = %95, %97
%98 = phi i64 [ %104, %97 ], [ %96, %95 ]
%99 = trunc i64 %98 to i32
%100 = sitofp i32 %99 to float
%101 = fmul float %100, %3
%102 = fmul float %101, %1
%103 = getelementptr inbounds float, float* %23, i64 %98
store float %102, float* %103
%104 = add nuw nsw i64 %98, 1
%105 = icmp eq i64 %104, %26
br i1 %105, label %106, label %97
106: ; preds = %97, %93, %16
%107 = sext i32 %19 to i64
%108 = getelementptr inbounds float, float* %23, i64 %107
%109 = load float, float* %108
%110 = fdiv float %2, %109
%111 = tail call i32 @fabs(float %110)
%112 = icmp sgt i32 %111, 1
br i1 %112, label %113, label %116
113: ; preds = %106
%114 = fpext float %110 to double
%115 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0), double %114)
br label %116
116: ; preds = %113, %106
%117 = load float*, float** %5
%118 = tail call i32 @scalefloats(float* %117, i32 %20, float %110)
%119 = icmp eq float** %4, null
br i1 %119, label %128, label %120
120: ; preds = %116
%121 = tail call i64 @malloc(i32 %21)
%122 = inttoptr i64 %121 to float*
store float* %122, float** %4
%123 = load float*, float** %5
%124 = tail call i32 @cumulativeSum(float* %123, float* %122, i32 %20)
%125 = load float*, float** %4
%126 = fmul float %3, 4.257000e+03
%127 = tail call i32 @scalefloats(float* %125, i32 %20, float %126)
br label %128
128: ; preds = %120, %116
%129 = icmp eq float** %6, null
br i1 %129, label %138, label %130
130: ; preds = %128
%131 = tail call i64 @malloc(i32 %21)
%132 = inttoptr i64 %131 to float*
store float* %132, float** %6
%133 = load float*, float** %5
%134 = tail call i32 @diffArray(float* %133, float* %132, i32 %20)
%135 = load float*, float** %6
%136 = fdiv float 1.000000e+00, %3
%137 = tail call i32 @scalefloats(float* %135, i32 %20, float %136)
br label %138
138: ; preds = %130, %128
%139 = icmp eq float** %7, null
br i1 %139, label %213, label %140
140: ; preds = %138
%141 = tail call i64 @malloc(i32 %21)
%142 = inttoptr i64 %141 to float*
store float* %142, float** %7
br i1 %24, label %213, label %143
143: ; preds = %140
%144 = zext i32 %20 to i64
%145 = icmp ult i32 %20, 8
br i1 %145, label %203, label %146
146: ; preds = %143
%147 = and i64 %144, 4294967288
%148 = insertelement <4 x float> poison, float %3, i64 0
%149 = shufflevector <4 x float> %148, <4 x float> poison, <4 x i32> zeroinitializer
%150 = insertelement <4 x float> poison, float %3, i64 0
%151 = shufflevector <4 x float> %150, <4 x float> poison, <4 x i32> zeroinitializer
%152 = add nsw i64 %147, -8
%153 = lshr exact i64 %152, 3
%154 = add nuw nsw i64 %153, 1
%155 = and i64 %154, 1
%156 = icmp eq i64 %152, 0
br i1 %156, label %187, label %157
157: ; preds = %146
%158 = and i64 %154, 4611686018427387902
br label %159
159: ; preds = %159, %157
%160 = phi i64 [ 0, %157 ], [ %183, %159 ]
%161 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %157 ], [ %184, %159 ]
%162 = phi i64 [ 0, %157 ], [ %185, %159 ]
%163 = add <4 x i32> %161, <i32 4, i32 4, i32 4, i32 4>
%164 = sitofp <4 x i32> %161 to <4 x float>
%165 = sitofp <4 x i32> %163 to <4 x float>
%166 = fmul <4 x float> %149, %164
%167 = fmul <4 x float> %151, %165
%168 = getelementptr inbounds float, float* %142, i64 %160
%169 = bitcast float* %168 to <4 x float>*
store <4 x float> %166, <4 x float>* %169
%170 = getelementptr inbounds float, float* %168, i64 4
%171 = bitcast float* %170 to <4 x float>*
store <4 x float> %167, <4 x float>* %171
%172 = or i64 %160, 8
%173 = add <4 x i32> %161, <i32 8, i32 8, i32 8, i32 8>
%174 = add <4 x i32> %161, <i32 12, i32 12, i32 12, i32 12>
%175 = sitofp <4 x i32> %173 to <4 x float>
%176 = sitofp <4 x i32> %174 to <4 x float>
%177 = fmul <4 x float> %149, %175
%178 = fmul <4 x float> %151, %176
%179 = getelementptr inbounds float, float* %142, i64 %172
%180 = bitcast float* %179 to <4 x float>*
store <4 x float> %177, <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 %160, 16
%184 = add <4 x i32> %161, <i32 16, i32 16, i32 16, i32 16>
%185 = add i64 %162, 2
%186 = icmp eq i64 %185, %158
br i1 %186, label %187, label %159
187: ; preds = %159, %146
%188 = phi i64 [ 0, %146 ], [ %183, %159 ]
%189 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %146 ], [ %184, %159 ]
%190 = icmp eq i64 %155, 0
br i1 %190, label %201, label %191
191: ; preds = %187
%192 = add <4 x i32> %189, <i32 4, i32 4, i32 4, i32 4>
%193 = sitofp <4 x i32> %189 to <4 x float>
%194 = sitofp <4 x i32> %192 to <4 x float>
%195 = fmul <4 x float> %149, %193
%196 = fmul <4 x float> %151, %194
%197 = getelementptr inbounds float, float* %142, i64 %188
%198 = bitcast float* %197 to <4 x float>*
store <4 x float> %195, <4 x float>* %198
%199 = getelementptr inbounds float, float* %197, i64 4
%200 = bitcast float* %199 to <4 x float>*
store <4 x float> %196, <4 x float>* %200
br label %201
201: ; preds = %187, %191
%202 = icmp eq i64 %147, %144
br i1 %202, label %213, label %203
203: ; preds = %143, %201
%204 = phi i64 [ 0, %143 ], [ %147, %201 ]
br label %205
205: ; preds = %203, %205
%206 = phi i64 [ %211, %205 ], [ %204, %203 ]
%207 = trunc i64 %206 to i32
%208 = sitofp i32 %207 to float
%209 = fmul float %208, %3
%210 = getelementptr inbounds float, float* %142, i64 %206
store float %209, float* %210
%211 = add nuw nsw i64 %206, 1
%212 = icmp eq i64 %211, %144
br i1 %212, label %213, label %205
213: ; preds = %205, %201, %140, %138
store i32 %20, i32* %8
ret void
}