float **smoothPath(int numWayPoints, int dimWayPoint, float **wayPoints,
                   float totalTime, float timeStep) {
  float **path;
  float pathAlpha = 0.7;
  float pathBeta = 0.3;
  float pathTolerance = 0.0000001;
  int numPoints = numWayPoints;
  int old_num_points = numWayPoints;
  int *injections = injectionCounter2Steps(numWayPoints, totalTime, timeStep);
  for (int i = 0; i < 3; i++) {
    if (i == 0) {
      float **tmp1 = inject(numPoints, dimWayPoint, wayPoints, injections[0]);
      numPoints = numPoints + ((injections[i]) * (numPoints - 1));
      path = smoother(numPoints, dimWayPoint, tmp1, pathAlpha, pathBeta,
                      pathTolerance);
      for (int i = 0; i < numPoints; i++) {
        free(tmp1[i]);
      }
      free(tmp1);
    } else {
      float **tmp1 = inject(numPoints, dimWayPoint, path, injections[i]);
      numPoints = numPoints + ((injections[i]) * (numPoints - 1));
      float **tmp2 = smoother(numPoints, dimWayPoint, tmp1, pathAlpha, pathBeta,
                              pathTolerance);
      for (int i = 0; i < numPoints; i++) {
        free(tmp1[i]);
      }
      free(tmp1);
      for (int i = 0; i < old_num_points; i++) {
        free(path[i]);
      }
      free(path);
      path = malloc(numPoints * sizeof(float *));
      for (int i = 0; i < numPoints; i++) {
        path[i] = malloc(dimWayPoint * sizeof(float));
      }
      for (int i = 0; i < numPoints; i++) {
        for (int j = 0; j < dimWayPoint; j++) {
          path[i][j] = tmp2[i][j];
        }
      }
      for (int i = 0; i < numPoints; i++) {
        free(tmp2[i]);
      }
      free(tmp2);
    }
    old_num_points = numPoints;
  }
  free(injections);
  float **finalPath = malloc((numPoints + 1) * sizeof(float *));
  for (int i = 0; i < numPoints + 1; i++) {
    finalPath[i] = malloc(dimWayPoint * sizeof(float));
  }
  finalPath[0][0] = numPoints + 1;
  for (int i = 0; i < numPoints; i++) {
    for (int j = 0; j < dimWayPoint; j++) {
      finalPath[i + 1][j] = path[i][j];
    }
  }
  for (int i = 0; i < numPoints; i++) {
    free(path[i]);
  }
  free(path);
  return finalPath;
}


x86 assembly (clang, -O0):
<smoothPath>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
movss  0xe91(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xe80(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  0xe6f(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x4(%rbp),%edi
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    $0x2,%al
call   1050 <injectionCounter2Steps@plt>
cltq
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    147e <smoothPath+0x32e>
cmpl   $0x0,-0x44(%rbp)
jne    128a <smoothPath+0x13a>
mov    -0x30(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    (%rax),%ecx
mov    $0x0,%al
call   1070 <inject@plt>
cltq
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x44(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x50(%rbp),%rdx
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x2c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mov    $0x3,%al
call   1040 <smoother@plt>
cltq
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    127c <smoothPath+0x12c>
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1251 <smoothPath+0x101>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
jmp    146a <smoothPath+0x31a>
mov    -0x30(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    $0x0,%al
call   1070 <inject@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x44(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x60(%rbp),%rdx
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x2c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mov    $0x3,%al
call   1040 <smoother@plt>
cltq
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    132c <smoothPath+0x1dc>
mov    -0x60(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1301 <smoothPath+0x1b1>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1367 <smoothPath+0x217>
mov    -0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    133c <smoothPath+0x1ec>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
movslq -0x30(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    13be <smoothPath+0x26e>
movslq -0x8(%rbp),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1388 <smoothPath+0x238>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    142f <smoothPath+0x2df>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    141c <smoothPath+0x2cc>
mov    -0x68(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x7c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    13d8 <smoothPath+0x288>
jmp    1421 <smoothPath+0x2d1>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    13c5 <smoothPath+0x275>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1461 <smoothPath+0x311>
mov    -0x68(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1436 <smoothPath+0x2e6>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11cb <smoothPath+0x7b>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14f4 <smoothPath+0x3a4>
movslq -0x8(%rbp),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x88(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    14aa <smoothPath+0x35a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm0
mov    -0x88(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    15a9 <smoothPath+0x459>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1590 <smoothPath+0x440>
mov    -0x20(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    152f <smoothPath+0x3df>
jmp    1595 <smoothPath+0x445>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1516 <smoothPath+0x3c6>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    15ea <smoothPath+0x49a>
mov    -0x20(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    15b3 <smoothPath+0x463>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<smoothPath>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rdx,0x68(%rsp)
mov    %esi,%r12d
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mov    %rdi,0x8(%rsp)
mov    $0x2,%al
call   1050 <injectionCounter2Steps@plt>
cltq
mov    %rax,0x38(%rsp)
movslq %r12d,%rax
lea    0x0(,%rax,4),%r14
mov    %eax,%r13d
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x80(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rax,0x50(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x70(%rsp)
mov    %r13d,%eax
and    $0x3,%eax
mov    %rax,0x60(%rsp)
mov    %rcx,0x78(%rsp)
shl    $0x5,%rcx
mov    %rcx,0x58(%rsp)
xor    %ebx,%ebx
mov    %r14,0x18(%rsp)
mov    %r12d,0x24(%rsp)
jmp    1217 <smoothPath+0xc7>
nopl   0x0(%rax,%rax,1)
mov    %ebx,%eax
mov    %rax,0x8(%rsp)
mov    0x18(%rsp),%r14
mov    0x28(%rsp),%rbx
mov    %r15,%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    $0x3,%rbx
je     15af <smoothPath+0x45f>
test   %rbx,%rbx
mov    %rbx,0x28(%rsp)
je     14d0 <smoothPath+0x380>
mov    0x38(%rsp),%r14
mov    (%r14,%rbx,4),%ecx
mov    0x8(%rsp),%rdi
mov    %r12d,%esi
mov    %rbp,0x10(%rsp)
mov    %rbp,%rdx
mov    %rdi,%rbp
xor    %eax,%eax
call   1070 <inject@plt>
mov    %r12d,%esi
movslq %eax,%r12
lea    -0x1(%rbp),%r15d
imul   (%r14,%rbx,4),%r15d
lea    (%r15,%rbp,1),%edi
mov    %r12,%rdx
movsd  0xd9a(%rip),%xmm0
movsd  0xd9a(%rip),%xmm1
movsd  0xd9a(%rip),%xmm2
mov    $0x3,%al
call   1040 <smoother@plt>
mov    %eax,0x44(%rsp)
add    %ebp,%r15d
mov    %r15,0x30(%rsp)
mov    %r15d,%r14d
jle    12a2 <smoothPath+0x152>
xor    %ebx,%ebx
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1290 <smoothPath+0x140>
mov    %r12,%rdi
call   1030 <free@plt>
test   %ebp,%ebp
mov    0x10(%rsp),%r12
jle    12d2 <smoothPath+0x182>
mov    %ebp,%ebx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    12c0 <smoothPath+0x170>
movslq 0x44(%rsp),%r15
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rbx
movslq %ebx,%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,%rbp
test   %ebx,%ebx
mov    0x24(%rsp),%r12d
jle    11f0 <smoothPath+0xa0>
xor    %ebx,%ebx
mov    0x18(%rsp),%r12
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdi
call   1060 <malloc@plt>
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1310 <smoothPath+0x1c0>
mov    0x30(%rsp),%rax
test   %eax,%eax
jle    158c <smoothPath+0x43c>
xor    %eax,%eax
mov    0x48(%rsp),%r8
mov    %rbp,%r9
mov    0x24(%rsp),%r12d
mov    0x60(%rsp),%r10
mov    0x58(%rsp),%r11
jmp    135d <smoothPath+0x20d>
xchg   %ax,%ax
add    $0x1,%rax
cmp    %r14,%rax
je     1560 <smoothPath+0x410>
test   %r12d,%r12d
jle    1350 <smoothPath+0x200>
mov    (%r15,%rax,8),%rcx
mov    0x0(%rbp,%rax,8),%rdx
cmp    $0x8,%r12d
jb     1387 <smoothPath+0x237>
lea    (%rcx,%r13,4),%rsi
cmp    %rsi,%rdx
jae    13fc <smoothPath+0x2ac>
lea    (%rdx,%r13,4),%rsi
cmp    %rsi,%rcx
jae    13fc <smoothPath+0x2ac>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r13,%rdi
test   %r10,%r10
je     13b4 <smoothPath+0x264>
mov    %r10,%rbx
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
jne    13a0 <smoothPath+0x250>
cmp    $0x3,%rdi
jb     1350 <smoothPath+0x200>
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  0x4(%rcx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
movss  0x8(%rcx,%rsi,4),%xmm0
movss  %xmm0,0x8(%rdx,%rsi,4)
movss  0xc(%rcx,%rsi,4),%xmm0
movss  %xmm0,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    13c0 <smoothPath+0x270>
jmp    1350 <smoothPath+0x200>
cmp    $0x18,%r8
jae    1406 <smoothPath+0x2b6>
xor    %esi,%esi
jmp    1468 <smoothPath+0x318>
mov    0x70(%rsp),%rdi
xor    %esi,%esi
nopl   (%rax)
movups (%rcx,%rsi,4),%xmm0
movups 0x10(%rcx,%rsi,4),%xmm1
movups %xmm0,(%rdx,%rsi,4)
movups %xmm1,0x10(%rdx,%rsi,4)
movups 0x20(%rcx,%rsi,4),%xmm0
movups 0x30(%rcx,%rsi,4),%xmm1
movups %xmm0,0x20(%rdx,%rsi,4)
movups %xmm1,0x30(%rdx,%rsi,4)
movups 0x40(%rcx,%rsi,4),%xmm0
movups 0x50(%rcx,%rsi,4),%xmm1
movups %xmm0,0x40(%rdx,%rsi,4)
movups %xmm1,0x50(%rdx,%rsi,4)
movups 0x60(%rcx,%rsi,4),%xmm0
movups 0x70(%rcx,%rsi,4),%xmm1
movups %xmm0,0x60(%rdx,%rsi,4)
movups %xmm1,0x70(%rdx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1410 <smoothPath+0x2c0>
cmpq   $0x0,0x78(%rsp)
je     14ab <smoothPath+0x35b>
lea    (%rdx,%rsi,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,4),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r11
jne    1490 <smoothPath+0x340>
mov    0x80(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r13,%rdi
mov    %r9,%rbp
je     1350 <smoothPath+0x200>
jmp    1389 <smoothPath+0x239>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rbp
mov    0x0(%rbp),%ecx
mov    0x8(%rsp),%r14
mov    %r14d,%edi
mov    %r12d,%esi
mov    0x68(%rsp),%rdx
xor    %eax,%eax
call   1070 <inject@plt>
movslq %eax,%r15
lea    -0x1(%r14),%ebx
imul   0x0(%rbp),%ebx
lea    (%rbx,%r14,1),%edi
mov    %r12d,%esi
mov    %r15,%rdx
movsd  0xaf4(%rip),%xmm0
movsd  0xaf4(%rip),%xmm1
movsd  0xaf4(%rip),%xmm2
mov    $0x3,%al
call   1040 <smoother@plt>
movslq %eax,%rbp
add    %ebx,%r14d
mov    %r14,0x8(%rsp)
jle    15a0 <smoothPath+0x450>
mov    %rbp,0x10(%rsp)
mov    %r14d,%ebx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1540 <smoothPath+0x3f0>
mov    0x10(%rsp),%rbp
jmp    11f7 <smoothPath+0xa7>
nopl   0x0(%rax)
mov    0x30(%rsp),%rax
test   %eax,%eax
jle    1587 <smoothPath+0x437>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1570 <smoothPath+0x420>
mov    0x30(%rsp),%rax
jmp    11f2 <smoothPath+0xa2>
mov    %rax,0x8(%rsp)
mov    0x18(%rsp),%r14
mov    0x24(%rsp),%r12d
jmp    11fc <smoothPath+0xac>
mov    0x28(%rsp),%rbx
mov    0x18(%rsp),%r14
jmp    1201 <smoothPath+0xb1>
mov    %rbp,0x10(%rsp)
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%ebp
movslq %ebp,%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,%r15
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
call   1060 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    15e0 <smoothPath+0x490>
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mov    (%r15),%rax
movss  %xmm0,(%rax)
mov    0x8(%rsp),%rax
test   %eax,%eax
mov    0x10(%rsp),%rbp
je     17f3 <smoothPath+0x6a3>
mov    %eax,%r14d
mov    %r13d,%r9d
and    $0xfffffff8,%r9d
mov    0x50(%rsp),%rax
mov    %eax,%r8d
and    $0x3,%r8d
movabs $0x3ffffffffffffffc,%r11
ff ff 3f
and    %rax,%r11
mov    %r13d,%r10d
and    $0x3,%r10d
mov    %r8,%rsi
shl    $0x5,%rsi
xor    %eax,%eax
jmp    1661 <smoothPath+0x511>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rbp
mov    %rdi,%rax
cmp    %r14,%rdi
je     17cd <smoothPath+0x67d>
test   %r12d,%r12d
jle    1710 <smoothPath+0x5c0>
lea    0x1(%rax),%rdi
mov    0x0(%rbp,%rax,8),%rcx
mov    0x8(%r15,%rax,8),%rax
cmp    $0x8,%r12d
jb     1698 <smoothPath+0x548>
lea    (%rcx,%r13,4),%rdx
cmp    %rdx,%rax
jae    171c <smoothPath+0x5cc>
lea    (%rax,%r13,4),%rdx
cmp    %rdx,%rcx
jae    171c <smoothPath+0x5cc>
xor    %edx,%edx
mov    %rdx,%rbp
not    %rbp
add    %r13,%rbp
test   %r10,%r10
je     16c4 <smoothPath+0x574>
mov    %r10,%rbx
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbx
jne    16b0 <smoothPath+0x560>
cmp    $0x3,%rbp
jb     1650 <smoothPath+0x500>
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
movss  0x4(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rax,%rdx,4)
movss  0x8(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x8(%rax,%rdx,4)
movss  0xc(%rcx,%rdx,4),%xmm0
movss  %xmm0,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r13
jne    16d0 <smoothPath+0x580>
jmp    1650 <smoothPath+0x500>
nopl   0x0(%rax)
add    $0x1,%rax
mov    %rax,%rdi
jmp    1655 <smoothPath+0x505>
cmpq   $0x18,0x48(%rsp)
jae    1728 <smoothPath+0x5d8>
xor    %edx,%edx
jmp    1788 <smoothPath+0x638>
mov    %r11,%rbp
xor    %edx,%edx
nopl   (%rax)
movups (%rcx,%rdx,4),%xmm0
movups 0x10(%rcx,%rdx,4),%xmm1
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
movups 0x20(%rcx,%rdx,4),%xmm0
movups 0x30(%rcx,%rdx,4),%xmm1
movups %xmm0,0x20(%rax,%rdx,4)
movups %xmm1,0x30(%rax,%rdx,4)
movups 0x40(%rcx,%rdx,4),%xmm0
movups 0x50(%rcx,%rdx,4),%xmm1
movups %xmm0,0x40(%rax,%rdx,4)
movups %xmm1,0x50(%rax,%rdx,4)
movups 0x60(%rcx,%rdx,4),%xmm0
movups 0x70(%rcx,%rdx,4),%xmm1
movups %xmm0,0x60(%rax,%rdx,4)
movups %xmm1,0x70(%rax,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbp
jne    1730 <smoothPath+0x5e0>
test   %r8,%r8
je     17bc <smoothPath+0x66c>
lea    (%rax,%rdx,4),%rbp
add    $0x10,%rbp
lea    (%rcx,%rdx,4),%rdx
add    $0x10,%rdx
xor    %ebx,%ebx
nop
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    17a0 <smoothPath+0x650>
mov    %r9,%rdx
cmp    %r13,%r9
jne    169a <smoothPath+0x54a>
jmp    1650 <smoothPath+0x500>
cmpl   $0x0,0x8(%rsp)
je     17f3 <smoothPath+0x6a3>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    17e0 <smoothPath+0x690>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r15,%rax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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