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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free_vector(float *, int, int);
void stub1(float, float *, float *);
void stub2(float, float *, float *);
float *vector(int, int);
void stoerm(float y[], float d2y[], int nv, float xs, float htot, int nstep,
            float yout[], void (*derivs)(float, float[], float[])) {
  int i, n, neqns, nn;
  float h, h2, halfh, x, *ytemp;
  ytemp = vector(1, nv);
  h = htot / nstep;
  halfh = 0.5 * h;
  neqns = nv / 2;
  for (i = 1; i <= neqns; i++) {
    n = neqns + i;
    ytemp[i] = y[i] + (ytemp[n] = h * (y[n] + halfh * d2y[i]));
  }
  x = xs + h;
  (*derivs)(x, ytemp, yout);
  h2 = h * h;
  for (nn = 2; nn <= nstep; nn++) {
    for (i = 1; i <= neqns; i++)
      ytemp[i] += (ytemp[(n = neqns + i)] += h2 * yout[i]);
    x += h;
    (*derivs)(x, ytemp, yout);
  }
  for (i = 1; i <= neqns; i++) {
    n = neqns + i;
    yout[n] = ytemp[n] / h + halfh * yout[i];
    yout[i] = ytemp[i];
  }
  free_vector(ytemp, 1, nv);
}


x86 assembly (clang, -O0):
<stoerm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x58(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtsi2ssl -0x20(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe83(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     121d <stoerm+0xfd>
mov    -0x3c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x44(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm1,(%rax,%rcx,4)
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    119f <stoerm+0x7f>
movss  -0x18(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%rax
movss  -0x50(%rbp),%xmm0
mov    -0x58(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   *%rax
movss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x2,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     12f8 <stoerm+0x1d8>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     12c8 <stoerm+0x1a8>
movss  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x58(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,-0x38(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1268 <stoerm+0x148>
movss  -0x44(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%rax
movss  -0x50(%rbp),%xmm0
mov    -0x58(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   *%rax
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1255 <stoerm+0x135>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1375 <stoerm+0x255>
mov    -0x3c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
divss  -0x44(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ff <stoerm+0x1df>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_vector@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stoerm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,%r12
mov    %ecx,%r14d
movaps %xmm1,0x40(%rsp)
movss  %xmm0,0xc(%rsp)
mov    %edx,%ebx
mov    %rsi,%r13
mov    %rdi,%r15
mov    $0x1,%edi
mov    %edx,%esi
call   1040 <vector@plt>
movaps 0x40(%rsp),%xmm5
mov    %rax,%rbp
mov    %r14d,0x2c(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
divss  %xmm0,%xmm5
movss  0xe84(%rip),%xmm6
mulss  %xmm5,%xmm6
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
movslq %eax,%rcx
mov    %rcx,0x10(%rsp)
mov    %ebx,0x1c(%rsp)
cmp    $0x2,%ebx
mov    %rax,0x20(%rsp)
jl     147e <stoerm+0x35e>
lea    0x1(%rax),%r9d
lea    -0x1(%r9),%rdx
mov    $0x1,%ecx
cmp    $0x4,%rdx
jb     13b6 <stoerm+0x296>
mov    %rdx,0x50(%rsp)
mov    0x10(%rsp),%rax
lea    0x4(,%rax,4),%rdi
add    %rbp,%rdi
lea    (%rax,%r9,1),%r8
lea    0x0(%rbp,%r8,4),%rbx
lea    0x4(%rbp),%rsi
lea    0x0(%rbp,%r9,4),%rdx
lea    0x4(%r15),%r11
lea    (%r15,%r9,4),%r10
lea    (%r15,%rax,4),%rax
add    $0x4,%rax
lea    (%r15,%r8,4),%r8
lea    0x0(,%r9,4),%r14
add    %r13,%r14
cmp    %rdx,%rdi
setb   0x40(%rsp)
cmp    %rbx,%rsi
setb   0x80(%rsp)
cmp    %r10,%rdi
setb   0x70(%rsp)
cmp    %rbx,%r11
setb   0x30(%rsp)
cmp    %r8,%rdi
setb   0xb(%rsp)
cmp    %rbx,%rax
setb   0x68(%rsp)
cmp    %r14,%rdi
lea    0x4(%r13),%rdi
setb   0x60(%rsp)
cmp    %rbx,%rdi
setb   %bl
cmp    %r10,%rsi
setb   %r10b
cmp    %rdx,%r11
setb   0x58(%rsp)
cmp    %r8,%rsi
setb   %r11b
cmp    %rdx,%rax
setb   %r8b
cmp    %r14,%rsi
setb   %sil
cmp    %rdx,%rdi
setb   %dl
mov    0x80(%rsp),%al
test   %al,0x40(%rsp)
jne    13b6 <stoerm+0x296>
mov    0x30(%rsp),%al
and    %al,0x70(%rsp)
jne    13b6 <stoerm+0x296>
mov    0x68(%rsp),%al
and    %al,0xb(%rsp)
jne    13b6 <stoerm+0x296>
and    %bl,0x60(%rsp)
jne    13b6 <stoerm+0x296>
and    0x58(%rsp),%r10b
jne    13b6 <stoerm+0x296>
and    %r8b,%r11b
jne    13b6 <stoerm+0x296>
and    %dl,%sil
jne    13b6 <stoerm+0x296>
mov    0x50(%rsp),%r10
mov    %r10,%rcx
and    $0xfffffffffffffffc,%rcx
movaps %xmm6,%xmm1
shufps $0x0,%xmm6,%xmm1
movaps %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm0
lea    -0x4(%rcx),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     18b1 <stoerm+0x791>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x10(%rsp),%rsi
lea    0x0(,%rsi,4),%rdx
add    %rbp,%rdx
lea    (%r15,%rsi,4),%rbx
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r15,%rsi,4),%xmm2
movups (%rbx,%rsi,4),%xmm3
movups 0x0(%r13,%rsi,4),%xmm4
mulps  %xmm1,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm0,%xmm4
movups %xmm4,(%rdx,%rsi,4)
addps  %xmm2,%xmm4
movups %xmm4,0x0(%rbp,%rsi,4)
movups 0x10(%r15,%rsi,4),%xmm2
movups 0x10(%rbx,%rsi,4),%xmm3
movups 0x10(%r13,%rsi,4),%xmm4
mulps  %xmm1,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm0,%xmm4
movups %xmm4,0x10(%rdx,%rsi,4)
addps  %xmm2,%xmm4
movups %xmm4,0x10(%rbp,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1320 <stoerm+0x200>
test   $0x1,%r8b
je     13a9 <stoerm+0x289>
mov    0x10(%rsp),%rdx
add    %rsi,%rdx
movups (%r15,%rsi,4),%xmm2
movups (%r15,%rdx,4),%xmm3
movups 0x0(%r13,%rsi,4),%xmm4
mulps  %xmm4,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm1,%xmm0
movups %xmm0,0x0(%rbp,%rdx,4)
addps  %xmm2,%xmm0
movups %xmm0,0x0(%rbp,%rsi,4)
cmp    %rcx,%r10
je     147e <stoerm+0x35e>
or     $0x1,%rcx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r9b
jne    13f9 <stoerm+0x2d9>
mov    0x10(%rsp),%rsi
add    %rcx,%rsi
movss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm6,%xmm0
addss  (%r15,%rsi,4),%xmm0
mulss  %xmm5,%xmm0
movss  (%r15,%rcx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm0,0x0(%rbp,%rsi,4)
movss  %xmm1,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
add    %r9,%rdx
je     147e <stoerm+0x35e>
mov    0x10(%rsp),%rsi
lea    (%r15,%rsi,4),%rdx
add    $0x4,%rdx
lea    0x4(,%rsi,4),%rsi
add    %rbp,%rsi
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm6,%xmm0
addss  -0x4(%rdx,%rcx,4),%xmm0
mulss  %xmm5,%xmm0
movss  (%r15,%rcx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm0,-0x4(%rsi,%rcx,4)
movss  %xmm1,0x0(%rbp,%rcx,4)
movss  0x4(%r13,%rcx,4),%xmm0
mulss  %xmm6,%xmm0
addss  (%rdx,%rcx,4),%xmm0
mulss  %xmm5,%xmm0
movss  0x4(%r15,%rcx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm0,(%rsi,%rcx,4)
movss  %xmm1,0x4(%rbp,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1420 <stoerm+0x300>
movaps %xmm6,0xa0(%rsp)
movss  0xc(%rsp),%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,0xc(%rsp)
mov    %rbp,%rdi
mov    %r12,%rsi
movaps %xmm5,0x40(%rsp)
call   *0x38(%rsp)
movaps 0x40(%rsp),%xmm4
cmpl   $0x2,0x2c(%rsp)
jge    160a <stoerm+0x4ea>
cmpl   $0x2,0x1c(%rsp)
movaps 0xa0(%rsp),%xmm5
mov    0x20(%rsp),%rsi
jl     1911 <stoerm+0x7f1>
add    $0x1,%esi
lea    -0x1(%rsi),%rcx
mov    $0x1,%eax
cmp    $0x4,%rcx
jb     18ca <stoerm+0x7aa>
mov    %rcx,0x38(%rsp)
mov    0x10(%rsp),%rcx
lea    (%r12,%rcx,4),%rdx
add    $0x4,%rdx
lea    (%rcx,%rsi,1),%r8
lea    (%r12,%r8,4),%rdi
lea    0x4(%r12),%rbx
lea    (%r12,%rsi,4),%r15
lea    0x4(%rbp,%rcx,4),%r10
lea    0x0(%rbp,%r8,4),%rcx
lea    0x4(%rbp),%r8
mov    %rsi,0x20(%rsp)
lea    0x0(,%rsi,4),%r9
add    %rbp,%r9
cmp    %r15,%rdx
setb   0xc(%rsp)
cmp    %rdi,%rbx
setb   %r11b
cmp    %rcx,%rdx
setb   %r14b
cmp    %rdi,%r10
setb   %sil
cmp    %r9,%rdx
setb   %r13b
cmp    %rdi,%r8
setb   0x40(%rsp)
cmp    %rcx,%rbx
setb   %dil
cmp    %r15,%r10
setb   %cl
cmp    %r9,%rbx
setb   %r9b
cmp    %r15,%r8
setb   %r15b
test   %r11b,0xc(%rsp)
jne    18c5 <stoerm+0x7a5>
and    %sil,%r14b
jne    18c5 <stoerm+0x7a5>
and    0x40(%rsp),%r13b
mov    0x20(%rsp),%rsi
jne    18ca <stoerm+0x7aa>
and    %cl,%dil
jne    18ca <stoerm+0x7aa>
and    %r15b,%r9b
jne    18ca <stoerm+0x7aa>
mov    0x38(%rsp),%rcx
mov    %rcx,%rdi
and    $0xfffffffffffffffc,%rdi
lea    0x1(%rdi),%rax
movaps %xmm4,%xmm0
shufps $0x0,%xmm4,%xmm0
movaps %xmm5,%xmm1
shufps $0x0,%xmm5,%xmm1
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r10,%rbx,4),%xmm2
divps  %xmm0,%xmm2
movups 0x4(%r12,%rbx,4),%xmm3
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,(%rdx,%rbx,4)
movups 0x4(%rbp,%rbx,4),%xmm2
movups %xmm2,0x4(%r12,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    15d0 <stoerm+0x4b0>
cmp    %rdi,%rcx
je     1911 <stoerm+0x7f1>
jmp    18ca <stoerm+0x7aa>
movaps %xmm4,%xmm2
mulss  %xmm4,%xmm2
mov    0x20(%rsp),%rax
lea    0x1(%rax),%r15d
mov    0x10(%rsp),%rax
lea    0x4(%rbp,%rax,4),%rbx
add    %r15,%rax
lea    0x0(%rbp,%rax,4),%rsi
lea    0x4(%rbp),%r9
lea    0x0(%rbp,%r15,4),%r8
lea    0x4(%r12),%r11
lea    (%r12,%r15,4),%rdi
lea    -0x1(%r15),%r10
lea    -0x5(%r15),%rcx
mov    %rcx,0x60(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    %r8,%rbx
setb   %al
cmp    %rsi,%r9
setb   %dl
and    %al,%dl
cmp    %rdi,%rbx
setb   %r14b
cmp    %rsi,%r11
setb   %al
and    %r14b,%al
or     %dl,%al
cmp    %rdi,%r9
setb   %sil
cmp    %r8,%r11
setb   %dl
and    %sil,%dl
or     %al,%dl
mov    %dl,0xb(%rsp)
mov    %r10,0x30(%rsp)
and    $0xfffffffffffffffc,%r10
mov    %r10,0x50(%rsp)
lea    0x1(%r10),%rax
mov    %rax,0x98(%rsp)
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
mov    %rcx,%rax
mov    %rcx,0x58(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x90(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x68(%rsp)
lea    0x14(%rbp),%r14
mov    $0x2,%r13d
movaps %xmm2,0x80(%rsp)
movaps %xmm3,0x70(%rsp)
jmp    172e <stoerm+0x60e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0xc(%rsp),%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0xc(%rsp)
mov    %rbp,%rdi
mov    %r12,%rsi
call   *0x38(%rsp)
movaps 0x70(%rsp),%xmm3
movaps 0x80(%rsp),%xmm2
movaps 0x40(%rsp),%xmm4
lea    0x1(%r13),%eax
cmp    0x2c(%rsp),%r13d
mov    %eax,%r13d
je     14b5 <stoerm+0x395>
cmpl   $0x2,0x1c(%rsp)
jl     16f0 <stoerm+0x5d0>
cmpq   $0x4,0x30(%rsp)
setb   %al
or     0xb(%rsp),%al
mov    $0x1,%ecx
jne    180d <stoerm+0x6ed>
cmpq   $0x4,0x60(%rsp)
jae    1759 <stoerm+0x639>
xor    %eax,%eax
jmp    17c0 <stoerm+0x6a0>
mov    0x90(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x4(%r12,%rax,4),%xmm0
movups (%rbx,%rax,4),%xmm1
mulps  %xmm3,%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%rbx,%rax,4)
movups -0x10(%r14,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,-0x10(%r14,%rax,4)
movups 0x14(%r12,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
mulps  %xmm3,%xmm0
addps  %xmm1,%xmm0
movups %xmm0,0x10(%rbx,%rax,4)
movups (%r14,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%r14,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1770 <stoerm+0x650>
testb  $0x1,0x58(%rsp)
je     17f5 <stoerm+0x6d5>
or     $0x1,%rax
movups (%r12,%rax,4),%xmm0
mov    0x10(%rsp),%rcx
add    %rax,%rcx
movups 0x0(%rbp,%rcx,4),%xmm1
mulps  %xmm3,%xmm0
addps  %xmm1,%xmm0
movups %xmm0,0x0(%rbp,%rcx,4)
movups 0x0(%rbp,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x0(%rbp,%rax,4)
mov    0x98(%rsp),%rcx
mov    0x50(%rsp),%rax
cmp    %rax,0x30(%rsp)
je     16f0 <stoerm+0x5d0>
mov    %rcx,%rax
test   $0x1,%r15b
jne    1844 <stoerm+0x724>
mov    0x10(%rsp),%rax
add    %rcx,%rax
movss  (%r12,%rcx,4),%xmm0
mulss  %xmm2,%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
addss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0x68(%rsp),%rcx
je     16f0 <stoerm+0x5d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r12,%rax,4),%xmm0
mulss  %xmm2,%xmm0
addss  -0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rax,4)
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  0x4(%r12,%rax,4),%xmm0
mulss  %xmm2,%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
addss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%r15
jne    1860 <stoerm+0x740>
jmp    16f0 <stoerm+0x5d0>
mov    $0x1,%esi
test   $0x1,%r8b
jne    137b <stoerm+0x25b>
jmp    13a9 <stoerm+0x289>
mov    0x20(%rsp),%rsi
mov    0x10(%rsp),%rdx
lea    0x0(,%rdx,4),%rcx
add    %rbp,%rcx
lea    (%r12,%rdx,4),%rdx
xchg   %ax,%ax
movss  (%rcx,%rax,4),%xmm0
divss  %xmm4,%xmm0
movss  (%r12,%rax,4),%xmm1
mulss  %xmm5,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,4)
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    18e0 <stoerm+0x7c0>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    0x1c(%rsp),%edx
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>

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

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