#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ EXIT_FAILURE;
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *, int);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
void spline(float x[], float y[], int n, float yp1, float ypn, float y2[]) {
  int i, k;
  float p, qn, sig, un, *u;
  {
    (u) = (float *)malloc((n - 1) * sizeof(float));
    if ((u) == NULL) {
      fprintf(stderr, "-E- %s line %d: Memory allocation failure.\n",
              "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
              "2022-01-22/02-19-57/repos/JauchOnGitHub/mohid.codeplex/refs/"
              "heads/master/codeplex/Software/OceanColor/readL2scan.c",
              1489);
      exit(EXIT_FAILURE);
    }
  };
  if (yp1 > 0.99e30)
    y2[0] = u[0] = 0.0;
  else {
    y2[0] = -0.5;
    u[0] = (3.0 / (x[1] - x[0])) * ((y[1] - y[0]) / (x[1] - x[0]) - yp1);
  }
  for (i = 1; i < n - 1; i++) {
    sig = (x[i] - x[i - 1]) / (x[i + 1] - x[i - 1]);
    p = sig * y2[i - 1] + 2.0;
    y2[i] = (sig - 1.0) / p;
    u[i] = (y[i + 1] - y[i]) / (x[i + 1] - x[i]) -
           (y[i] - y[i - 1]) / (x[i] - x[i - 1]);
    u[i] = (6.0 * u[i] / (x[i + 1] - x[i - 1]) - sig * u[i - 1]) / p;
  }
  if (ypn > 0.99e30)
    qn = un = 0.0;
  else {
    qn = 0.5;
    un = (3.0 / (x[n - 1] - x[n - 2])) *
         (ypn - (y[n - 1] - y[n - 2]) / (x[n - 1] - x[n - 2]));
  }
  y2[n - 1] = (un - qn * u[n - 2]) / (qn * y2[n - 2] + 1.0);
  for (k = n - 2; k >= 0; k--) {
    y2[k] = y2[k] * y2[k + 1] + u[k];
  }
  free(u);
}


x86 assembly (clang, -O0):
<spline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    11b2 <spline+0x72>
mov    0x2e56(%rip),%rax
mov    (%rax),%edi
lea    0xe9d(%rip),%rsi
lea    0xec2(%rip),%rdx
mov    $0x5d1,%ecx
call   1040 <fprintf@plt>
mov    0x2e2d(%rip),%rax
mov    (%rax),%edi
call   1060 <exit@plt>
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe3d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    11e8 <spline+0xa8>
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    1258 <spline+0x118>
mov    -0x28(%rbp),%rax
movss  0xe34(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdf3(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
subss  (%rax),%xmm2
divss  %xmm2,%xmm1
subss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1448 <spline+0x308>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd41(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd13(%rip),%xmm1
subsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc4b(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    125f <spline+0x11f>
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xba7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1478 <spline+0x338>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    151f <spline+0x3df>
movss  0xbac(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb53(%rip),%xmm0
divsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm3
divss  %xmm3,%xmm2
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x38(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xa99(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     15f7 <spline+0x4b7>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    159e <spline+0x45e>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spline>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r12
movss  %xmm1,(%rsp)
movss  %xmm0,0x4(%rsp)
mov    %edx,%r14d
mov    %rsi,%r15
mov    %rdi,%rbx
lea    -0x4(,%r14,4),%edi
ff
call   1050 <malloc@plt>
test   %rax,%rax
je     1549 <spline+0x409>
movss  0x4(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
ucomisd 0xe76(%rip),%xmm0
jbe    119c <spline+0x5c>
movl   $0x0,(%rax)
movl   $0x0,(%r12)
jmp    11e6 <spline+0xa6>
movl   $0xbf000000,(%r12)
bf
movss  0x4(%rbx),%xmm0
subss  (%rbx),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xe4c(%rip),%xmm2
movss  0x4(%r15),%xmm3
subss  (%r15),%xmm3
divsd  %xmm1,%xmm2
divss  %xmm0,%xmm3
subss  %xmm4,%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  (%rsp),%xmm11
lea    -0x1(%r14),%ecx
cmp    $0x3,%r14d
jl     1420 <spline+0x2e0>
mov    %ecx,%edx
lea    (%rax,%rdx,4),%rsi
cmp    %r12,%rsi
jbe    1314 <spline+0x1d4>
lea    (%r12,%rdx,4),%rsi
cmp    %rsi,%rax
jae    1314 <spline+0x1d4>
add    $0xffffffffffffffff,%rdx
xor    %esi,%esi
movss  0xe03(%rip),%xmm8
movsd  0xde3(%rip),%xmm1
movsd  0xde3(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rsi,4),%xmm4
movss  0x4(%rbx,%rsi,4),%xmm3
subss  %xmm4,%xmm3
movss  0x8(%rbx,%rsi,4),%xmm5
subss  %xmm4,%xmm5
divss  %xmm5,%xmm3
movss  (%r12,%rsi,4),%xmm4
mulss  %xmm3,%xmm4
addss  %xmm8,%xmm4
xorps  %xmm5,%xmm5
cvtss2sd %xmm3,%xmm5
addsd  %xmm1,%xmm5
cvtss2sd %xmm4,%xmm4
divsd  %xmm4,%xmm5
cvtsd2ss %xmm5,%xmm5
movss  %xmm5,0x4(%r12,%rsi,4)
movss  0x4(%r15,%rsi,4),%xmm5
movss  0x8(%r15,%rsi,4),%xmm6
subss  %xmm5,%xmm6
movss  0x4(%rbx,%rsi,4),%xmm7
movss  0x8(%rbx,%rsi,4),%xmm0
subss  %xmm7,%xmm0
subss  (%r15,%rsi,4),%xmm5
divss  %xmm0,%xmm6
subss  (%rbx,%rsi,4),%xmm7
divss  %xmm7,%xmm5
subss  %xmm5,%xmm6
movss  %xmm6,0x4(%rax,%rsi,4)
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
mulsd  %xmm2,%xmm0
movss  0x8(%rbx,%rsi,4),%xmm5
subss  (%rbx,%rsi,4),%xmm5
cvtss2sd %xmm5,%xmm5
divsd  %xmm5,%xmm0
mulss  (%rax,%rsi,4),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm0
divsd  %xmm4,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rax,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1240 <spline+0x100>
jmp    1420 <spline+0x2e0>
movss  (%r12),%xmm1
movss  (%rax),%xmm4
mov    $0x1,%esi
movss  0xcfc(%rip),%xmm8
movsd  0xcdb(%rip),%xmm9
movsd  0xcda(%rip),%xmm10
xchg   %ax,%ax
movsd  (%rbx,%rsi,4),%xmm5
movss  -0x4(%rbx,%rsi,4),%xmm6
shufps $0x0,%xmm6,%xmm6
subps  %xmm6,%xmm5
movaps %xmm5,%xmm6
shufps $0x55,%xmm5,%xmm6
divss  %xmm6,%xmm5
mulss  %xmm5,%xmm1
addss  %xmm8,%xmm1
xorps  %xmm7,%xmm7
cvtss2sd %xmm5,%xmm7
addsd  %xmm9,%xmm7
xorps  %xmm6,%xmm6
cvtss2sd %xmm1,%xmm6
divsd  %xmm6,%xmm7
xorps  %xmm1,%xmm1
cvtsd2ss %xmm7,%xmm1
movss  %xmm1,(%r12,%rsi,4)
movsd  (%r15,%rsi,4),%xmm7
movss  -0x4(%r15,%rsi,4),%xmm0
movlhps %xmm7,%xmm0
shufps $0xe2,%xmm7,%xmm0
shufps $0xe1,%xmm7,%xmm7
movsd  (%rbx,%rsi,4),%xmm2
movss  -0x4(%rbx,%rsi,4),%xmm3
movlhps %xmm2,%xmm3
shufps $0xe2,%xmm2,%xmm3
shufps $0xe1,%xmm2,%xmm2
subps  %xmm0,%xmm7
subps  %xmm3,%xmm2
divps  %xmm2,%xmm7
movaps %xmm7,%xmm0
shufps $0x55,%xmm7,%xmm0
subss  %xmm0,%xmm7
movss  %xmm7,(%rax,%rsi,4)
xorps  %xmm0,%xmm0
cvtss2sd %xmm7,%xmm0
mulsd  %xmm10,%xmm0
movss  0x4(%rbx,%rsi,4),%xmm2
subss  -0x4(%rbx,%rsi,4),%xmm2
cvtss2sd %xmm2,%xmm2
divsd  %xmm2,%xmm0
mulss  %xmm4,%xmm5
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
subsd  %xmm2,%xmm0
divsd  %xmm6,%xmm0
xorps  %xmm4,%xmm4
cvtsd2ss %xmm0,%xmm4
movss  %xmm4,(%rax,%rsi,4)
lea    0x1(%rsi),%rdi
mov    %rdi,%rsi
cmp    %rdi,%rdx
jne    1340 <spline+0x200>
movslq %ecx,%rdx
xorps  %xmm0,%xmm0
cvtss2sd %xmm11,%xmm0
ucomisd 0xbcd(%rip),%xmm0
jbe    1444 <spline+0x304>
lea    -0x2(%r14),%ecx
movslq %ecx,%rsi
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
jmp    149e <spline+0x35e>
movss  (%rbx,%rdx,4),%xmm0
lea    -0x2(%r14),%ecx
movslq %r14d,%rsi
subss  -0x8(%rbx,%rsi,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xba3(%rip),%xmm2
divsd  %xmm1,%xmm2
movss  (%r15,%rdx,4),%xmm1
subss  -0x8(%r15,%rsi,4),%xmm1
add    $0xfffffffffffffffe,%rsi
divss  %xmm0,%xmm1
subss  %xmm1,%xmm11
xorps  %xmm0,%xmm0
cvtss2sd %xmm11,%xmm0
mulsd  %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
movss  0xb8e(%rip),%xmm0
movss  (%rax,%rsi,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulss  (%r12,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xb5f(%rip),%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%r12,%rdx,4)
cmp    $0x2,%r14d
jl     1536 <spline+0x3f6>
mov    %ecx,%edx
test   $0x1,%cl
jne    14fb <spline+0x3bb>
movss  (%r12,%rdx,4),%xmm0
mulss  0x4(%r12,%rdx,4),%xmm0
addss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
add    $0xffffffffffffffff,%rdx
test   %ecx,%ecx
je     1536 <spline+0x3f6>
nop
movss  (%r12,%rdx,4),%xmm0
mulss  0x4(%r12,%rdx,4),%xmm0
addss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
mulss  -0x4(%r12,%rdx,4),%xmm0
addss  -0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,-0x4(%r12,%rdx,4)
add    $0xfffffffffffffffe,%rdx
cmp    $0xffffffffffffffff,%rdx
jne    1500 <spline+0x3c0>
mov    %rax,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1030 <free@plt>
mov    0x2a90(%rip),%rax
mov    (%rax),%edi
lea    0xad7(%rip),%rsi
lea    0xafc(%rip),%rdx
mov    $0x5d1,%ecx
call   1040 <fprintf@plt>
mov    0x2a67(%rip),%rax
mov    (%rax),%edi
call   1060 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [44 x i8] c"-E- %s line %d: Memory allocation failure.\0A\00"
@.str.1 = [179 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/JauchOnGitHub/mohid.codeplex/refs/heads/master/codeplex/Software/OceanColor/readL2scan.c\00"
@EXIT_FAILURE = global i32 0
define void @spline(float* %0, float* %1, i32 %2, float %3, float %4, float* %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca float
%11 = alloca float
%12 = alloca float*
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float*
store float* %0, float** %7
store float* %1, float** %8
store i32 %2, i32* %9
store float %3, float* %10
store float %4, float* %11
store float* %5, float** %12
%20 = load i32, i32* %9
%21 = sub nsw i32 %20, 1
%22 = sext i32 %21 to i64
%23 = mul i64 %22, 4
%24 = trunc i64 %23 to i32
%25 = call i64 @malloc(i32 %24)
%26 = inttoptr i64 %25 to float*
store float* %26, float** %19
%27 = load float*, float** %19
%28 = icmp eq float* %27, null
br i1 %28, label %29, label %34
29: ; preds = %6
%30 = load i32, i32* @stderr
%31 = call i32 @fprintf(i32 %30, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([179 x i8], [179 x i8]* @.str.1, i64 0, i64 0), i32 1489)
%32 = load i32, i32* @EXIT_FAILURE
%33 = call i32 @exit(i32 %32)
unreachable
34: ; preds = %6
%35 = load float, float* %10
%36 = fpext float %35 to double
%37 = fcmp ogt double %36, 9.900000e+29
br i1 %37, label %38, label %43
38: ; preds = %34
%39 = load float*, float** %19
%40 = getelementptr inbounds float, float* %39, i64 0
store float 0.000000e+00, float* %40
%41 = load float*, float** %12
%42 = getelementptr inbounds float, float* %41, i64 0
store float 0.000000e+00, float* %42
br label %77
43: ; preds = %34
%44 = load float*, float** %12
%45 = getelementptr inbounds float, float* %44, i64 0
store float -5.000000e-01, float* %45
%46 = load float*, float** %7
%47 = getelementptr inbounds float, float* %46, i64 1
%48 = load float, float* %47
%49 = load float*, float** %7
%50 = getelementptr inbounds float, float* %49, i64 0
%51 = load float, float* %50
%52 = fsub float %48, %51
%53 = fpext float %52 to double
%54 = fdiv double 3.000000e+00, %53
%55 = load float*, float** %8
%56 = getelementptr inbounds float, float* %55, i64 1
%57 = load float, float* %56
%58 = load float*, float** %8
%59 = getelementptr inbounds float, float* %58, i64 0
%60 = load float, float* %59
%61 = fsub float %57, %60
%62 = load float*, float** %7
%63 = getelementptr inbounds float, float* %62, i64 1
%64 = load float, float* %63
%65 = load float*, float** %7
%66 = getelementptr inbounds float, float* %65, i64 0
%67 = load float, float* %66
%68 = fsub float %64, %67
%69 = fdiv float %61, %68
%70 = load float, float* %10
%71 = fsub float %69, %70
%72 = fpext float %71 to double
%73 = fmul double %54, %72
%74 = fptrunc double %73 to float
%75 = load float*, float** %19
%76 = getelementptr inbounds float, float* %75, i64 0
store float %74, float* %76
br label %77
77: ; preds = %43, %38
store i32 1, i32* %13
br label %78
78: ; preds = %227, %77
%79 = load i32, i32* %13
%80 = load i32, i32* %9
%81 = sub nsw i32 %80, 1
%82 = icmp slt i32 %79, %81
br i1 %82, label %83, label %230
83: ; preds = %78
%84 = load float*, float** %7
%85 = load i32, i32* %13
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float, float* %84, i64 %86
%88 = load float, float* %87
%89 = load float*, float** %7
%90 = load i32, i32* %13
%91 = sub nsw i32 %90, 1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %89, i64 %92
%94 = load float, float* %93
%95 = fsub float %88, %94
%96 = load float*, float** %7
%97 = load i32, i32* %13
%98 = add nsw i32 %97, 1
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %96, i64 %99
%101 = load float, float* %100
%102 = load float*, float** %7
%103 = load i32, i32* %13
%104 = sub nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %102, i64 %105
%107 = load float, float* %106
%108 = fsub float %101, %107
%109 = fdiv float %95, %108
store float %109, float* %17
%110 = load float, float* %17
%111 = load float*, float** %12
%112 = load i32, i32* %13
%113 = sub nsw i32 %112, 1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds float, float* %111, i64 %114
%116 = load float, float* %115
%117 = fmul float %110, %116
%118 = fpext float %117 to double
%119 = fadd double %118, 2.000000e+00
%120 = fptrunc double %119 to float
store float %120, float* %15
%121 = load float, float* %17
%122 = fpext float %121 to double
%123 = fsub double %122, 1.000000e+00
%124 = load float, float* %15
%125 = fpext float %124 to double
%126 = fdiv double %123, %125
%127 = fptrunc double %126 to float
%128 = load float*, float** %12
%129 = load i32, i32* %13
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds float, float* %128, i64 %130
store float %127, float* %131
%132 = load float*, float** %8
%133 = load i32, i32* %13
%134 = add nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %132, i64 %135
%137 = load float, float* %136
%138 = load float*, float** %8
%139 = load i32, i32* %13
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %138, i64 %140
%142 = load float, float* %141
%143 = fsub float %137, %142
%144 = load float*, float** %7
%145 = load i32, i32* %13
%146 = add nsw i32 %145, 1
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds float, float* %144, i64 %147
%149 = load float, float* %148
%150 = load float*, float** %7
%151 = load i32, i32* %13
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %150, i64 %152
%154 = load float, float* %153
%155 = fsub float %149, %154
%156 = fdiv float %143, %155
%157 = load float*, float** %8
%158 = load i32, i32* %13
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %157, i64 %159
%161 = load float, float* %160
%162 = load float*, float** %8
%163 = load i32, i32* %13
%164 = sub nsw i32 %163, 1
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %162, i64 %165
%167 = load float, float* %166
%168 = fsub float %161, %167
%169 = load float*, float** %7
%170 = load i32, i32* %13
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float, float* %169, i64 %171
%173 = load float, float* %172
%174 = load float*, float** %7
%175 = load i32, i32* %13
%176 = sub nsw i32 %175, 1
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %174, i64 %177
%179 = load float, float* %178
%180 = fsub float %173, %179
%181 = fdiv float %168, %180
%182 = fsub float %156, %181
%183 = load float*, float** %19
%184 = load i32, i32* %13
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %183, i64 %185
store float %182, float* %186
%187 = load float*, float** %19
%188 = load i32, i32* %13
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float, float* %187, i64 %189
%191 = load float, float* %190
%192 = fpext float %191 to double
%193 = fmul double 6.000000e+00, %192
%194 = load float*, float** %7
%195 = load i32, i32* %13
%196 = add nsw i32 %195, 1
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %194, i64 %197
%199 = load float, float* %198
%200 = load float*, float** %7
%201 = load i32, i32* %13
%202 = sub nsw i32 %201, 1
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %200, i64 %203
%205 = load float, float* %204
%206 = fsub float %199, %205
%207 = fpext float %206 to double
%208 = fdiv double %193, %207
%209 = load float, float* %17
%210 = load float*, float** %19
%211 = load i32, i32* %13
%212 = sub nsw i32 %211, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds float, float* %210, i64 %213
%215 = load float, float* %214
%216 = fmul float %209, %215
%217 = fpext float %216 to double
%218 = fsub double %208, %217
%219 = load float, float* %15
%220 = fpext float %219 to double
%221 = fdiv double %218, %220
%222 = fptrunc double %221 to float
%223 = load float*, float** %19
%224 = load i32, i32* %13
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds float, float* %223, i64 %225
store float %222, float* %226
br label %227
227: ; preds = %83
%228 = load i32, i32* %13
%229 = add nsw i32 %228, 1
store i32 %229, i32* %13
br label %78
230: ; preds = %78
%231 = load float, float* %11
%232 = fpext float %231 to double
%233 = fcmp ogt double %232, 9.900000e+29
br i1 %233, label %234, label %235
234: ; preds = %230
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %16
br label %283
235: ; preds = %230
store float 5.000000e-01, float* %16
%236 = load float*, float** %7
%237 = load i32, i32* %9
%238 = sub nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds float, float* %236, i64 %239
%241 = load float, float* %240
%242 = load float*, float** %7
%243 = load i32, i32* %9
%244 = sub nsw i32 %243, 2
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float, float* %242, i64 %245
%247 = load float, float* %246
%248 = fsub float %241, %247
%249 = fpext float %248 to double
%250 = fdiv double 3.000000e+00, %249
%251 = load float, float* %11
%252 = load float*, float** %8
%253 = load i32, i32* %9
%254 = sub nsw i32 %253, 1
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds float, float* %252, i64 %255
%257 = load float, float* %256
%258 = load float*, float** %8
%259 = load i32, i32* %9
%260 = sub nsw i32 %259, 2
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float, float* %258, i64 %261
%263 = load float, float* %262
%264 = fsub float %257, %263
%265 = load float*, float** %7
%266 = load i32, i32* %9
%267 = sub nsw i32 %266, 1
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds float, float* %265, i64 %268
%270 = load float, float* %269
%271 = load float*, float** %7
%272 = load i32, i32* %9
%273 = sub nsw i32 %272, 2
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds float, float* %271, i64 %274
%276 = load float, float* %275
%277 = fsub float %270, %276
%278 = fdiv float %264, %277
%279 = fsub float %251, %278
%280 = fpext float %279 to double
%281 = fmul double %250, %280
%282 = fptrunc double %281 to float
store float %282, float* %18
br label %283
283: ; preds = %235, %234
%284 = load float, float* %18
%285 = load float, float* %16
%286 = load float*, float** %19
%287 = load i32, i32* %9
%288 = sub nsw i32 %287, 2
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds float, float* %286, i64 %289
%291 = load float, float* %290
%292 = fneg float %285
%293 = call float @llvm.fmuladd.f32(float %292, float %291, float %284)
%294 = fpext float %293 to double
%295 = load float, float* %16
%296 = load float*, float** %12
%297 = load i32, i32* %9
%298 = sub nsw i32 %297, 2
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds float, float* %296, i64 %299
%301 = load float, float* %300
%302 = fmul float %295, %301
%303 = fpext float %302 to double
%304 = fadd double %303, 1.000000e+00
%305 = fdiv double %294, %304
%306 = fptrunc double %305 to float
%307 = load float*, float** %12
%308 = load i32, i32* %9
%309 = sub nsw i32 %308, 1
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds float, float* %307, i64 %310
store float %306, float* %311
%312 = load i32, i32* %9
%313 = sub nsw i32 %312, 2
store i32 %313, i32* %14
br label %314
314: ; preds = %339, %283
%315 = load i32, i32* %14
%316 = icmp sge i32 %315, 0
br i1 %316, label %317, label %342
317: ; preds = %314
%318 = load float*, float** %12
%319 = load i32, i32* %14
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds float, float* %318, i64 %320
%322 = load float, float* %321
%323 = load float*, float** %12
%324 = load i32, i32* %14
%325 = add nsw i32 %324, 1
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds float, float* %323, i64 %326
%328 = load float, float* %327
%329 = load float*, float** %19
%330 = load i32, i32* %14
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds float, float* %329, i64 %331
%333 = load float, float* %332
%334 = call float @llvm.fmuladd.f32(float %322, float %328, float %333)
%335 = load float*, float** %12
%336 = load i32, i32* %14
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %335, i64 %337
store float %334, float* %338
br label %339
339: ; preds = %317
%340 = load i32, i32* %14
%341 = add nsw i32 %340, -1
store i32 %341, i32* %14
br label %314
342: ; preds = %314
%343 = load float*, float** %19
%344 = call i32 @free(float* %343)
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [44 x i8] c"-E- %s line %d: Memory allocation failure.\0A\00"
@.str.1 = [179 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/JauchOnGitHub/mohid.codeplex/refs/heads/master/codeplex/Software/OceanColor/readL2scan.c\00"
@EXIT_FAILURE = global i32 0
define void @spline(float* nocapture %0, float* nocapture %1, i32 %2, float %3, float %4, float* nocapture %5) {
%7 = add nsw i32 %2, -1
%8 = sext i32 %7 to i64
%9 = shl i32 %7, 2
%10 = tail call i64 @malloc(i32 %9)
%11 = inttoptr i64 %10 to float*
%12 = inttoptr i64 %10 to i8*
%13 = icmp eq i64 %10, 0
br i1 %13, label %14, label %19
14: ; preds = %6
%15 = load i32, i32* @stderr
%16 = tail call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([179 x i8], [179 x i8]* @.str.1, i64 0, i64 0), i32 1489)
%17 = load i32, i32* @EXIT_FAILURE
%18 = tail call i32 @exit(i32 %17)
unreachable
19: ; preds = %6
%20 = fpext float %3 to double
%21 = fcmp ogt double %20, 9.900000e+29
br i1 %21, label %22, label %23
22: ; preds = %19
store float 0.000000e+00, float* %11
store float 0.000000e+00, float* %5
br label %39
23: ; preds = %19
store float -5.000000e-01, float* %5
%24 = getelementptr inbounds float, float* %0, i64 1
%25 = load float, float* %24
%26 = load float, float* %0
%27 = fsub float %25, %26
%28 = fpext float %27 to double
%29 = fdiv double 3.000000e+00, %28
%30 = getelementptr inbounds float, float* %1, i64 1
%31 = load float, float* %30
%32 = load float, float* %1
%33 = fsub float %31, %32
%34 = fdiv float %33, %27
%35 = fsub float %34, %3
%36 = fpext float %35 to double
%37 = fmul double %29, %36
%38 = fptrunc double %37 to float
store float %38, float* %11
br label %39
39: ; preds = %23, %22
%40 = icmp sgt i32 %2, 2
br i1 %40, label %41, label %165
41: ; preds = %39
%42 = zext i32 %7 to i64
%43 = getelementptr float, float* %5, i64 %42
%44 = bitcast float* %43 to i8*
%45 = getelementptr float, float* %11, i64 %42
%46 = icmp ugt float* %45, %5
%47 = icmp ult i8* %12, %44
%48 = and i1 %46, %47
br i1 %48, label %49, label %104
49: ; preds = %41, %49
%50 = phi i64 [ %57, %49 ], [ 1, %41 ]
%51 = getelementptr inbounds float, float* %0, i64 %50
%52 = load float, float* %51
%53 = add nsw i64 %50, -1
%54 = getelementptr inbounds float, float* %0, i64 %53
%55 = load float, float* %54
%56 = fsub float %52, %55
%57 = add nuw nsw i64 %50, 1
%58 = getelementptr inbounds float, float* %0, i64 %57
%59 = load float, float* %58
%60 = fsub float %59, %55
%61 = fdiv float %56, %60
%62 = getelementptr inbounds float, float* %5, i64 %53
%63 = load float, float* %62
%64 = fmul float %63, %61
%65 = fadd float %64, 2.000000e+00
%66 = fpext float %61 to double
%67 = fadd double %66, -1.000000e+00
%68 = fpext float %65 to double
%69 = fdiv double %67, %68
%70 = fptrunc double %69 to float
%71 = getelementptr inbounds float, float* %5, i64 %50
store float %70, float* %71
%72 = getelementptr inbounds float, float* %1, i64 %57
%73 = load float, float* %72
%74 = getelementptr inbounds float, float* %1, i64 %50
%75 = load float, float* %74
%76 = fsub float %73, %75
%77 = load float, float* %58
%78 = load float, float* %51
%79 = fsub float %77, %78
%80 = fdiv float %76, %79
%81 = getelementptr inbounds float, float* %1, i64 %53
%82 = load float, float* %81
%83 = fsub float %75, %82
%84 = load float, float* %54
%85 = fsub float %78, %84
%86 = fdiv float %83, %85
%87 = fsub float %80, %86
%88 = getelementptr inbounds float, float* %11, i64 %50
store float %87, float* %88
%89 = fpext float %87 to double
%90 = fmul double %89, 6.000000e+00
%91 = load float, float* %58
%92 = load float, float* %54
%93 = fsub float %91, %92
%94 = fpext float %93 to double
%95 = fdiv double %90, %94
%96 = getelementptr inbounds float, float* %11, i64 %53
%97 = load float, float* %96
%98 = fmul float %61, %97
%99 = fpext float %98 to double
%100 = fsub double %95, %99
%101 = fdiv double %100, %68
%102 = fptrunc double %101 to float
store float %102, float* %88
%103 = icmp eq i64 %57, %42
br i1 %103, label %165, label %49
104: ; preds = %41
%105 = load float, float* %5
%106 = load float, float* %11
br label %107
107: ; preds = %104, %107
%108 = phi float [ %106, %104 ], [ %163, %107 ]
%109 = phi float [ %105, %104 ], [ %131, %107 ]
%110 = phi i64 [ 1, %104 ], [ %115, %107 ]
%111 = getelementptr inbounds float, float* %0, i64 %110
%112 = add nsw i64 %110, -1
%113 = getelementptr inbounds float, float* %0, i64 %112
%114 = load float, float* %113
%115 = add nuw nsw i64 %110, 1
%116 = getelementptr inbounds float, float* %0, i64 %115
%117 = bitcast float* %111 to <2 x float>*
%118 = load <2 x float>, <2 x float>* %117
%119 = insertelement <2 x float> poison, float %114, i64 0
%120 = shufflevector <2 x float> %119, <2 x float> poison, <2 x i32> zeroinitializer
%121 = fsub <2 x float> %118, %120
%122 = extractelement <2 x float> %121, i64 0
%123 = extractelement <2 x float> %121, i64 1
%124 = fdiv float %122, %123
%125 = fmul float %109, %124
%126 = fadd float %125, 2.000000e+00
%127 = fpext float %124 to double
%128 = fadd double %127, -1.000000e+00
%129 = fpext float %126 to double
%130 = fdiv double %128, %129
%131 = fptrunc double %130 to float
%132 = getelementptr inbounds float, float* %5, i64 %110
store float %131, float* %132
%133 = getelementptr inbounds float, float* %1, i64 %110
%134 = bitcast float* %133 to <2 x float>*
%135 = load <2 x float>, <2 x float>* %134
%136 = shufflevector <2 x float> %135, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%137 = bitcast float* %111 to <2 x float>*
%138 = load <2 x float>, <2 x float>* %137
%139 = shufflevector <2 x float> %138, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%140 = getelementptr inbounds float, float* %1, i64 %112
%141 = load float, float* %140
%142 = insertelement <2 x float> %135, float %141, i64 1
%143 = fsub <2 x float> %136, %142
%144 = load float, float* %113
%145 = insertelement <2 x float> %138, float %144, i64 1
%146 = fsub <2 x float> %139, %145
%147 = fdiv <2 x float> %143, %146
%148 = shufflevector <2 x float> %147, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%149 = fsub <2 x float> %147, %148
%150 = extractelement <2 x float> %149, i64 0
%151 = getelementptr inbounds float, float* %11, i64 %110
store float %150, float* %151
%152 = fpext float %150 to double
%153 = fmul double %152, 6.000000e+00
%154 = load float, float* %116
%155 = load float, float* %113
%156 = fsub float %154, %155
%157 = fpext float %156 to double
%158 = fdiv double %153, %157
%159 = fmul float %124, %108
%160 = fpext float %159 to double
%161 = fsub double %158, %160
%162 = fdiv double %161, %129
%163 = fptrunc double %162 to float
store float %163, float* %151
%164 = icmp eq i64 %115, %42
br i1 %164, label %165, label %107
165: ; preds = %107, %49, %39
%166 = fpext float %4 to double
%167 = fcmp ogt double %166, 9.900000e+29
br i1 %167, label %168, label %171
168: ; preds = %165
%169 = add nsw i32 %2, -2
%170 = sext i32 %169 to i64
br label %191
171: ; preds = %165
%172 = getelementptr inbounds float, float* %0, i64 %8
%173 = load float, float* %172
%174 = add nsw i32 %2, -2
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %0, i64 %175
%177 = load float, float* %176
%178 = fsub float %173, %177
%179 = fpext float %178 to double
%180 = fdiv double 3.000000e+00, %179
%181 = getelementptr inbounds float, float* %1, i64 %8
%182 = load float, float* %181
%183 = getelementptr inbounds float, float* %1, i64 %175
%184 = load float, float* %183
%185 = fsub float %182, %184
%186 = fdiv float %185, %178
%187 = fsub float %4, %186
%188 = fpext float %187 to double
%189 = fmul double %180, %188
%190 = fptrunc double %189 to float
br label %191
191: ; preds = %168, %171
%192 = phi i64 [ %170, %168 ], [ %175, %171 ]
%193 = phi i32 [ %169, %168 ], [ %174, %171 ]
%194 = phi float [ 0.000000e+00, %168 ], [ 5.000000e-01, %171 ]
%195 = phi float [ 0.000000e+00, %168 ], [ %190, %171 ]
%196 = getelementptr inbounds float, float* %11, i64 %192
%197 = load float, float* %196
%198 = fneg float %194
%199 = tail call float @llvm.fmuladd.f32(float %198, float %197, float %195)
%200 = fpext float %199 to double
%201 = getelementptr inbounds float, float* %5, i64 %192
%202 = load float, float* %201
%203 = fmul float %194, %202
%204 = fpext float %203 to double
%205 = fadd double %204, 1.000000e+00
%206 = fdiv double %200, %205
%207 = fptrunc double %206 to float
%208 = getelementptr inbounds float, float* %5, i64 %8
store float %207, float* %208
%209 = icmp sgt i32 %2, 1
br i1 %209, label %210, label %245
210: ; preds = %191
%211 = zext i32 %193 to i64
%212 = and i64 %211, 1
%213 = icmp eq i64 %212, 0
br i1 %213, label %214, label %224
214: ; preds = %210
%215 = getelementptr inbounds float, float* %5, i64 %211
%216 = load float, float* %215
%217 = add nuw nsw i64 %211, 1
%218 = getelementptr inbounds float, float* %5, i64 %217
%219 = load float, float* %218
%220 = getelementptr inbounds float, float* %11, i64 %211
%221 = load float, float* %220
%222 = tail call float @llvm.fmuladd.f32(float %216, float %219, float %221)
store float %222, float* %215
%223 = add nsw i64 %211, -1
br label %224
224: ; preds = %214, %210
%225 = phi i64 [ %211, %210 ], [ %223, %214 ]
%226 = icmp eq i32 %193, 0
br i1 %226, label %245, label %227
227: ; preds = %224, %227
%228 = phi i64 [ %243, %227 ], [ %225, %224 ]
%229 = getelementptr inbounds float, float* %5, i64 %228
%230 = load float, float* %229
%231 = add nuw nsw i64 %228, 1
%232 = getelementptr inbounds float, float* %5, i64 %231
%233 = load float, float* %232
%234 = getelementptr inbounds float, float* %11, i64 %228
%235 = load float, float* %234
%236 = tail call float @llvm.fmuladd.f32(float %230, float %233, float %235)
store float %236, float* %229
%237 = add nsw i64 %228, -1
%238 = getelementptr inbounds float, float* %5, i64 %237
%239 = load float, float* %238
%240 = getelementptr inbounds float, float* %11, i64 %237
%241 = load float, float* %240
%242 = tail call float @llvm.fmuladd.f32(float %239, float %236, float %241)
store float %242, float* %238
%243 = add nsw i64 %228, -2
%244 = icmp eq i64 %237, 0
br i1 %244, label %245, label %227
245: ; preds = %224, %227, %191
%246 = tail call i32 @free(float* %11)
ret void
}