#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 floor(float);
float fmaxf(float, float);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(float *, float *, int);
float sqrtf(float);
int step_forward_k(float *tgt_p, float *src_p, float *v, int nz, int nx,
                   float rz, float rx, float s, int k, float dt, float CFL,
                   float dx, float dz) {
  int iz;
  int ix;
  int ioff;
  float two = 2.0;
  float k2 = k * k, k_rz = rz / k2, k_rx = rx / k2, k_s = 2.f * (k_rz + k_rx);
  int k_nz = k * nz, k1_nz = (k - 1) * nz, k1 = k - 1, kp1 = k + 1;
  float src_iz_plus_1, src_iz_minus_1, src_ix_iz, src_ix_plus_1, src_ix_minus_1,
      tgt_ix_iz, vel;
  int ioffkzp, ioffkzm, ioffkxp, ioffkxm, num_cfl = 0;
  float *tgt = (float *)malloc(nx * nz * sizeof(float));
  memcpy(tgt, tgt_p, nx * nz * sizeof(float));
  for (ix = kp1; ix < nx - kp1; ix++) {
    for (iz = kp1; iz < nz - kp1; iz++) {
      ioff = iz + ix * nz;
      vel = sqrtf(v[ioff]);
      k = floor(vel * dt / (CFL * fmaxf(dx, dz))) + 1;
      k2 = k * k;
      k_rz = rz / k2;
      k_rx = rx / k2;
      k_s = 2.f * (k_rz + k_rx);
      k_nz = k * nz;
      k1_nz = (k - 1) * nz;
      k1 = k - 1;
      kp1 = k + 1;
      ioffkzp = ioff + k;
      ioffkzm = ioff - k;
      ioffkxp = ioff + k_nz;
      ioffkxm = ioff - k_nz;
      tgt_ix_iz = 0.125f * (4.f * tgt[ioff] + tgt[ioff + 1] + tgt[ioff + nz] +
                            tgt[ioff - 1] + tgt[ioff - nz]);
      src_ix_iz =
          0.125f * (4.f * src_p[ioff] + src_p[ioff + 1] + src_p[ioff + nz] +
                    src_p[ioff - 1] + src_p[ioff - nz]);
      src_ix_plus_1 = 0.125f * (4.f * src_p[ioffkxp] + src_p[ioffkxp + 1] +
                                src_p[ioffkxp + nz] + src_p[ioffkxp - 1] +
                                src_p[ioffkxp - nz]);
      src_ix_minus_1 = 0.125f * (4.f * src_p[ioffkxm] + src_p[ioffkxm + 1] +
                                 src_p[ioffkxm + nz] + src_p[ioffkxm - 1] +
                                 src_p[ioffkxm - nz]);
      src_iz_plus_1 = 0.125f * (4.f * src_p[ioffkzp] + src_p[ioffkzp + 1] +
                                src_p[ioffkzp + nz] + src_p[ioffkzp - 1] +
                                src_p[ioffkzp - nz]);
      src_iz_minus_1 = 0.125f * (4.f * src_p[ioffkzm] + src_p[ioffkzm + 1] +
                                 src_p[ioffkzm + nz] + src_p[ioffkzm - 1] +
                                 src_p[ioffkzm - nz]);
      vel = 0.125f * (4.f * v[ioff] + v[ioff + 1] + v[ioff + nz] + v[ioff - 1] +
                      v[ioff - nz]);
      tgt_p[ioff] =
          two * src_ix_iz - tgt_ix_iz +
          vel * (k_rz * (src_iz_plus_1 + src_iz_minus_1) +
                 k_rx * (src_ix_plus_1 + src_ix_minus_1) - k_s * src_ix_iz);
    }
  }
  free(tgt);
  return num_cfl;
}


x86 assembly (clang, -O0):
<step_forward_k>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
movss  %xmm3,-0x34(%rbp)
movss  %xmm4,-0x38(%rbp)
movss  %xmm5,-0x3c(%rbp)
movss  %xmm6,-0x40(%rbp)
movss  0xe63(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x24(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x28(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x58(%rbp),%xmm1
addss  -0x5c(%rbp),%xmm1
movss  0xe1e(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0xa0(%rbp)
mov    -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
call   1040 <memcpy@plt>
mov    -0x70(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    -0x70(%rbp),%ecx
cmp    %ecx,%eax
jge    17dd <step_forward_k+0x68d>
mov    -0x70(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x70(%rbp),%ecx
cmp    %ecx,%eax
jge    17ca <step_forward_k+0x67a>
mov    -0x44(%rbp),%eax
mov    -0x48(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <sqrtf@plt>
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x34(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm5
movss  -0x40(%rbp),%xmm4
movaps %xmm4,%xmm6
movaps %xmm5,%xmm2
cmpunordss %xmm2,%xmm2
movaps %xmm2,%xmm3
pand   %xmm6,%xmm3
maxss  %xmm5,%xmm4
pandn  %xmm4,%xmm2
por    %xmm3,%xmm2
mulss  %xmm2,%xmm1
divss  %xmm1,%xmm0
call   1070 <floor@plt>
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x24(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x28(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x58(%rbp),%xmm1
addss  -0x5c(%rbp),%xmm1
movss  0xcc4(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0xa8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xc3d(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0xa8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0xa8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0xa8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0xbea(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xbbb(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0xb71(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x98(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x98(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xb3f(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x98(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x98(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x98(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0xaec(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x9c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xaba(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x9c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x9c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x9c(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0xa67(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x90(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xa32(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0x9df(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x9ad(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x94(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x94(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0x95a(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x92e(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0x8e4(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x50(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x58(%rbp),%xmm3
movss  -0x74(%rbp),%xmm4
addss  -0x78(%rbp),%xmm4
movss  -0x5c(%rbp),%xmm2
movss  -0x80(%rbp),%xmm5
addss  -0x84(%rbp),%xmm5
ff
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x60(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1275 <step_forward_k+0x125>
jmp    17cf <step_forward_k+0x67f>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    125e <step_forward_k+0x10e>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<step_forward_k>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
movaps %xmm6,0x40(%rsp)
movss  %xmm5,(%rsp)
movss  %xmm4,0x8(%rsp)
movss  %xmm3,0x24(%rsp)
mov    %r9d,%r13d
movss  %xmm1,0x20(%rsp)
movss  %xmm0,0x1c(%rsp)
mov    %r8d,%ebp
mov    %ecx,%r14d
mov    %rdx,0x38(%rsp)
mov    %rsi,%rbx
mov    %rdi,0x30(%rsp)
lea    0x1(%r13),%r15d
mov    %ecx,%r12d
imul   %r8d,%r12d
shl    $0x2,%r12d
mov    %r12d,%edi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %rax,%rdi
mov    0x30(%rsp),%rsi
mov    %r12d,%edx
call   1040 <memcpy@plt>
mov    %ebp,0x14(%rsp)
sub    %r15d,%ebp
cmp    %ebp,%r15d
jge    171e <step_forward_k+0x5ce>
movss  (%rsp),%xmm3
movaps %xmm3,%xmm1
cmpunordss %xmm3,%xmm1
movaps %xmm1,%xmm0
movaps 0x40(%rsp),%xmm2
andps  %xmm2,%xmm0
maxss  %xmm3,%xmm2
andnps %xmm2,%xmm1
orps   %xmm0,%xmm1
mulss  0x8(%rsp),%xmm1
movaps %xmm1,0x110(%rsp)
movslq %r14d,%rax
movslq %r15d,%rdx
lea    -0x1(%rdx),%r10
imul   %rax,%r10
lea    0x1(%rdx),%r9
imul   %rax,%r9
mov    %rax,%r12
imul   %rdx,%r12
mov    %r14d,%r11d
imul   %r15d,%r11d
mov    %rax,0x50(%rsp)
neg    %eax
mov    %eax,0x18(%rsp)
lea    -0x1(%r11),%edi
add    $0xfffffffe,%r11d
lea    0x2(%r13),%esi
imul   %r14d,%esi
add    $0xffffffff,%esi
imul   %r14d,%r13d
add    $0xffffffff,%r13d
lea    0x1(%r12),%rbp
jmp    12cc <step_forward_k+0x17c>
cs nopw 0x0(%rax,%rax,1)
mov    0x90(%rsp),%rdx
add    $0x1,%rdx
mov    0x14(%rsp),%eax
sub    %r15d,%eax
cltq
mov    0x50(%rsp),%rcx
mov    0x88(%rsp),%r10
add    %rcx,%r10
mov    0x80(%rsp),%r9
add    %rcx,%r9
mov    0x78(%rsp),%r12
add    %rcx,%r12
mov    0x68(%rsp),%rdi
add    %r14d,%edi
mov    0x70(%rsp),%r11
add    %r14d,%r11d
mov    0x60(%rsp),%rsi
add    %r14d,%esi
mov    0x98(%rsp),%r13
add    %r14d,%r13d
mov    0x58(%rsp),%rbp
add    %rcx,%rbp
cmp    %rax,%rdx
jge    171e <step_forward_k+0x5ce>
mov    %r14d,%eax
sub    %r15d,%eax
cmp    %eax,%r15d
mov    %r13,0x98(%rsp)
mov    %rdx,0x90(%rsp)
mov    %r10,0x88(%rsp)
mov    %r9,0x80(%rsp)
mov    %r12,0x78(%rsp)
mov    %r11,0x70(%rsp)
mov    %rdi,0x68(%rsp)
mov    %rsi,0x60(%rsp)
mov    %rbp,0x58(%rsp)
jge    1260 <step_forward_k+0x110>
movslq %r15d,%rcx
lea    (%r10,%rcx,1),%rax
mov    0x38(%rsp),%rdx
lea    (%rdx,%rax,4),%rdx
mov    %rdx,0x40(%rsp)
lea    (%rbx,%rax,4),%rdx
mov    %rdx,(%rsp)
mov    0x28(%rsp),%r8
lea    (%r8,%rax,4),%rax
mov    %rax,0x108(%rsp)
lea    (%r12,%rcx,1),%rax
mov    0x30(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
mov    %rax,0x100(%rsp)
lea    (%r12,%r15,1),%eax
mov    %rax,0xf8(%rsp)
lea    (%r15,%rdi,1),%eax
mov    %rax,0xf0(%rsp)
lea    (%r15,%r11,1),%eax
mov    %rax,0xe8(%rsp)
lea    (%r15,%rsi,1),%eax
mov    %rax,0xe0(%rsp)
lea    (%r15,%r13,1),%eax
mov    %rax,0xd8(%rsp)
lea    (%r9,%r15,1),%eax
mov    %rax,0xd0(%rsp)
lea    (%r10,%r15,1),%eax
mov    %rax,0xc8(%rsp)
lea    0x0(%rbp,%rcx,1),%rax
lea    (%r8,%rax,4),%rdx
mov    %rdx,0xc0(%rsp)
lea    (%rbx,%rax,4),%rdx
mov    %rdx,0xb8(%rsp)
mov    0x38(%rsp),%rdx
lea    (%rdx,%rax,4),%r13
mov    %rcx,0x8(%rsp)
lea    (%r9,%rcx,1),%rax
lea    (%rdx,%rax,4),%rcx
mov    %rcx,0xb0(%rsp)
lea    (%rbx,%rax,4),%rcx
mov    %rcx,0xa8(%rsp)
lea    (%r8,%rax,4),%rax
mov    %rax,0xa0(%rsp)
xor    %r12d,%r12d
jmp    1701 <step_forward_k+0x5b1>
cs nopw 0x0(%rax,%rax,1)
call   1060 <sqrtf@plt>
mulss  0x24(%rsp),%xmm0
divss  0x110(%rsp),%xmm0
call   1070 <floor@plt>
lea    0x1(%rax),%ebp
mov    %ebp,%ecx
imul   %ebp,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mov    %ebp,%ecx
imul   %r14d,%ecx
lea    0x2(%rax),%r15d
mov    %eax,%esi
mov    0xf8(%rsp),%rdx
add    %r12,%rdx
add    %rdx,%rsi
lea    (%rcx,%rdx,1),%rdi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm1
add    $0x1,%edi
movslq %edi,%rdi
movss  0xb93(%rip),%xmm8
mulss  %xmm8,%xmm1
addss  (%rbx,%rdi,4),%xmm1
mov    %r14d,%edi
imul   %r15d,%edi
add    %edx,%edi
movslq %edi,%rdi
addss  (%rbx,%rdi,4),%xmm1
mov    0xf0(%rsp),%rdi
lea    (%rdi,%r12,1),%r8d
add    %r8d,%ecx
movslq %ecx,%rcx
addss  (%rbx,%rcx,4),%xmm1
mov    0x18(%rsp),%edi
imul   %edi,%ebp
mov    %r14d,%ecx
imul   %eax,%ecx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rbx,%rcx,4),%xmm1
lea    (%rdx,%rbp,1),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm2
lea    0x1(%rdx,%rbp,1),%ecx
movslq %ecx,%rcx
mulss  %xmm8,%xmm2
addss  (%rbx,%rcx,4),%xmm2
mov    %edi,%ecx
imul   %eax,%ecx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rbx,%rcx,4),%xmm2
lea    0x1(%rsi),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm4
lea    0x2(%rsi),%ecx
movslq %ecx,%rcx
mulss  %xmm8,%xmm4
addss  (%rbx,%rcx,4),%xmm4
mov    0xd0(%rsp),%rcx
lea    (%rcx,%r12,1),%ecx
lea    0x1(%rax,%rcx,1),%ecx
movslq %ecx,%rcx
addss  (%rbx,%rcx,4),%xmm4
movslq %esi,%rcx
addss  (%rbx,%rcx,4),%xmm4
mov    0xc8(%rsp),%rcx
add    %r12d,%ecx
lea    0x1(%rax,%rcx,1),%ecx
movslq %ecx,%rcx
addss  (%rbx,%rcx,4),%xmm4
mov    %r8d,%ecx
sub    %eax,%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm3
mov    $0xfffffffe,%ecx
sub    %eax,%ecx
imul   %r14d,%ecx
add    %edx,%ecx
sub    %eax,%edx
movslq %edx,%rdx
mulss  %xmm8,%xmm3
addss  (%rbx,%rdx,4),%xmm3
add    %r8d,%ebp
mov    0xe0(%rsp),%rdx
add    %r12d,%edx
sub    %eax,%edx
movslq %edx,%rdx
addss  (%rbx,%rdx,4),%xmm3
mov    0xe8(%rsp),%rdx
add    %r12d,%edx
sub    %eax,%edx
movslq %edx,%rdx
addss  (%rbx,%rdx,4),%xmm3
mov    0xd8(%rsp),%rdx
add    %r12d,%edx
sub    %eax,%edx
movslq %edx,%rax
addss  (%rbx,%rax,4),%xmm3
movss  0x1c(%rsp),%xmm6
divss  %xmm0,%xmm6
movss  0x20(%rsp),%xmm5
divss  %xmm0,%xmm5
movss  0xa49(%rip),%xmm9
mulss  %xmm9,%xmm4
mulss  %xmm9,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm6,%xmm3
mov    0xc0(%rsp),%rax
movss  -0x4(%rax,%r12,4),%xmm0
mulss  %xmm8,%xmm0
addss  (%rax,%r12,4),%xmm0
mov    0xa0(%rsp),%rdx
addss  (%rdx,%r12,4),%xmm0
addss  -0x8(%rax,%r12,4),%xmm0
mov    0x108(%rsp),%rax
addss  (%rax,%r12,4),%xmm0
mov    0xb8(%rsp),%rax
movss  -0x4(%rax,%r12,4),%xmm4
mulss  %xmm8,%xmm4
addss  (%rax,%r12,4),%xmm4
mov    0xa8(%rsp),%rdx
addss  (%rdx,%r12,4),%xmm4
addss  -0x8(%rax,%r12,4),%xmm4
addss  %xmm5,%xmm6
mov    (%rsp),%rax
addss  (%rax,%r12,4),%xmm4
mulss  %xmm9,%xmm4
mulss  %xmm9,%xmm1
movslq %ebp,%rax
addss  (%rbx,%rax,4),%xmm2
movslq %ecx,%rax
addss  (%rbx,%rax,4),%xmm2
mulss  %xmm9,%xmm2
movss  -0x4(%r13,%r12,4),%xmm7
mulss  %xmm8,%xmm7
addss  0x0(%r13,%r12,4),%xmm7
mov    0xb0(%rsp),%rax
addss  (%rax,%r12,4),%xmm7
addss  -0x8(%r13,%r12,4),%xmm7
addss  %xmm1,%xmm2
mov    0x40(%rsp),%rax
addss  (%rax,%r12,4),%xmm7
mulss  %xmm9,%xmm7
mulss  0x95e(%rip),%xmm0
mulss  0x95a(%rip),%xmm6
mulss  %xmm4,%xmm6
addss  %xmm4,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm5,%xmm2
addss  %xmm2,%xmm3
addss  %xmm3,%xmm6
mulss  %xmm7,%xmm6
addss  %xmm4,%xmm6
mov    0x100(%rsp),%rax
movss  %xmm6,(%rax,%r12,4)
mov    %r14d,%eax
sub    %r15d,%eax
cltq
mov    0x8(%rsp),%rcx
add    %r12,%rcx
add    $0x1,%rcx
add    $0x1,%r12
cmp    %rax,%rcx
jge    1260 <step_forward_k+0x110>
movss  -0x4(%r13,%r12,4),%xmm0
ucomiss 0x901(%rip),%xmm0
jb     1410 <step_forward_k+0x2c0>
sqrtss %xmm0,%xmm0
jmp    1415 <step_forward_k+0x2c5>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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