double _dywapitch_computeWaveletPitch(const double *samples, int startsample,
                                      int samplecount) {
  double pitchF = 0.0;
  int i, j;
  double si, si1;
  samplecount = _floor_power2(samplecount);
  double *sam = (double *)malloc(sizeof(double) * samplecount);
  memcpy(sam, samples + startsample, sizeof(double) * samplecount);
  int curSamNb = samplecount;
  int *distances = (int *)malloc(sizeof(int) * samplecount);
  int *mins = (int *)malloc(sizeof(int) * samplecount);
  int *maxs = (int *)malloc(sizeof(int) * samplecount);
  int nbMins, nbMaxs;
  int maxFLWTlevels = 6;
  double maxF = 3000.;
  int differenceLevelsN = 3;
  double maximaThresholdRatio = 0.75;
  double ampltitudeThreshold;
  double theDC = 0.0;
  {
    double maxValue = 0.0;
    double minValue = 0.0;
    for (i = 0; i < samplecount; i++) {
      si = sam[i];
      theDC = theDC + si;
      if (si > maxValue)
        maxValue = si;
      if (si < minValue)
        minValue = si;
    }
    theDC = theDC / samplecount;
    maxValue = maxValue - theDC;
    minValue = minValue - theDC;
    double amplitudeMax = (maxValue > -minValue ? maxValue : -minValue);
    ampltitudeThreshold = amplitudeMax * maximaThresholdRatio;
  }
  int curLevel = 0;
  double curModeDistance = -1.;
  int delta;
  while (1) {
    delta = 44100. / (_2power(curLevel) * maxF);
    if (curSamNb < 2)
      goto cleanup;
    double dv, previousDV = -1000;
    nbMins = nbMaxs = 0;
    int lastMinIndex = -1000000;
    int lastmaxIndex = -1000000;
    int findMax = 0;
    int findMin = 0;
    for (i = 2; i < curSamNb; i++) {
      si = sam[i] - theDC;
      si1 = sam[i - 1] - theDC;
      if (si1 <= 0 && si > 0)
        findMax = 1;
      if (si1 >= 0 && si < 0)
        findMin = 1;
      dv = si - si1;
      if (previousDV > -1000) {
        if (findMin && previousDV < 0 && dv >= 0) {
          if (fabs(si) >= ampltitudeThreshold) {
            if (i > lastMinIndex + delta) {
              mins[nbMins++] = i;
              lastMinIndex = i;
              findMin = 0;
            } else {
            }
          } else {
          }
        }
        if (findMax && previousDV > 0 && dv <= 0) {
          if (fabs(si) >= ampltitudeThreshold) {
            if (i > lastmaxIndex + delta) {
              maxs[nbMaxs++] = i;
              lastmaxIndex = i;
              findMax = 0;
            } else {
            }
          } else {
          }
        }
      }
      previousDV = dv;
    }
    if (nbMins == 0 && nbMaxs == 0) {
      goto cleanup;
    }
    int d;
    memset(distances, 0, samplecount * sizeof(int));
    for (i = 0; i < nbMins; i++) {
      for (j = 1; j < differenceLevelsN; j++) {
        if (i + j < nbMins) {
          d = _iabs(mins[i] - mins[i + j]);
          distances[d] = distances[d] + 1;
        }
      }
    }
    for (i = 0; i < nbMaxs; i++) {
      for (j = 1; j < differenceLevelsN; j++) {
        if (i + j < nbMaxs) {
          d = _iabs(maxs[i] - maxs[i + j]);
          distances[d] = distances[d] + 1;
        }
      }
    }
    int bestDistance = -1;
    int bestValue = -1;
    for (i = 0; i < curSamNb; i++) {
      int summed = 0;
      for (j = -delta; j <= delta; j++) {
        if (i + j >= 0 && i + j < curSamNb)
          summed += distances[i + j];
      }
      if (summed == bestValue) {
        if (i == 2 * bestDistance)
          bestDistance = i;
      } else if (summed > bestValue) {
        bestValue = summed;
        bestDistance = i;
      }
    }
    double distAvg = 0.0;
    double nbDists = 0;
    for (j = -delta; j <= delta; j++) {
      if (bestDistance + j >= 0 && bestDistance + j < samplecount) {
        int nbDist = distances[bestDistance + j];
        if (nbDist > 0) {
          nbDists += nbDist;
          distAvg += (bestDistance + j) * nbDist;
        }
      }
    }
    distAvg /= nbDists;
    if (curModeDistance > -1.) {
      double similarity = fabs(distAvg * 2 - curModeDistance);
      if (similarity <= 2 * delta) {
        pitchF = 44100. / (_2power(curLevel - 1) * curModeDistance);
        goto cleanup;
      }
    }
    curModeDistance = distAvg;
    curLevel = curLevel + 1;
    if (curLevel >= maxFLWTlevels) {
      goto cleanup;
    }
    if (curSamNb < 2) {
      goto cleanup;
    }
    for (i = 0; i < curSamNb / 2; i++) {
      sam[i] = (sam[2 * i] + sam[2 * i + 1]) / 2.;
    }
    curSamNb /= 2;
  }
cleanup:
  free(distances);
  free(mins);
  free(maxs);
  free(sam);
  return pitchF;
}


x86 assembly (clang, -O0):
<_dywapitch_computeWaveletPitch>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1080 <_floor_power2@plt>
mov    %eax,-0x10(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x8(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0x10(%rbp),%rdx
shl    $0x3,%rdx
call   1060 <memcpy@plt>
mov    -0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x6,-0x64(%rbp)
movsd  0xdf5(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x3,-0x74(%rbp)
movsd  0xdd9(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12de <_dywapitch_computeWaveletPitch+0x16e>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jbe    12a7 <_dywapitch_computeWaveletPitch+0x137>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x28(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    12cb <_dywapitch_computeWaveletPitch+0x15b>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    12d0 <_dywapitch_computeWaveletPitch+0x160>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1254 <_dywapitch_computeWaveletPitch+0xe4>
movsd  -0x90(%rbp),%xmm0
ff
cvtsi2sdl -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    136d <_dywapitch_computeWaveletPitch+0x1fd>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
jmp    1394 <_dywapitch_computeWaveletPitch+0x224>
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0xac(%rbp)
movsd  0xc45(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xac(%rbp),%edi
mov    $0x0,%al
call   1090 <_2power@plt>
cvtsi2sd %eax,%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  0xc27(%rip),%xmm0
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xbc(%rbp)
cmpl   $0x2,-0x3c(%rbp)
jge    140e <_dywapitch_computeWaveletPitch+0x29e>
jmp    1b80 <_dywapitch_computeWaveletPitch+0xa10>
movsd  0xc0a(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0xfff0bdc0,-0xd4(%rbp)
bd f0 ff
movl   $0xfff0bdc0,-0xd8(%rbp)
bd f0 ff
movl   $0x0,-0xdc(%rbp)
movl   $0x0,-0xe0(%rbp)
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    169b <_dywapitch_computeWaveletPitch+0x52b>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x28(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x30(%rbp),%xmm0
jb     14ca <_dywapitch_computeWaveletPitch+0x35a>
movsd  -0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    14ca <_dywapitch_computeWaveletPitch+0x35a>
movl   $0x1,-0xdc(%rbp)
movsd  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14f4 <_dywapitch_computeWaveletPitch+0x384>
xorps  %xmm0,%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    14f4 <_dywapitch_computeWaveletPitch+0x384>
movl   $0x1,-0xe0(%rbp)
movsd  -0x28(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  0xb0a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    167d <_dywapitch_computeWaveletPitch+0x50d>
cmpl   $0x0,-0xe0(%rbp)
je     15cc <_dywapitch_computeWaveletPitch+0x45c>
xorps  %xmm0,%xmm0
ucomisd -0xd0(%rbp),%xmm0
ff
jbe    15cc <_dywapitch_computeWaveletPitch+0x45c>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     15cc <_dywapitch_computeWaveletPitch+0x45c>
movsd  -0x28(%rbp),%xmm0
movaps 0xad1(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     15c2 <_dywapitch_computeWaveletPitch+0x452>
mov    -0x1c(%rbp),%eax
mov    -0xd4(%rbp),%ecx
add    -0xbc(%rbp),%ecx
cmp    %ecx,%eax
jle    15b8 <_dywapitch_computeWaveletPitch+0x448>
mov    -0x1c(%rbp),%edx
mov    -0x50(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x5c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
mov    %eax,-0xd4(%rbp)
movl   $0x0,-0xe0(%rbp)
jmp    15bd <_dywapitch_computeWaveletPitch+0x44d>
jmp    15bd <_dywapitch_computeWaveletPitch+0x44d>
jmp    15c7 <_dywapitch_computeWaveletPitch+0x457>
jmp    15c7 <_dywapitch_computeWaveletPitch+0x457>
jmp    15cc <_dywapitch_computeWaveletPitch+0x45c>
cmpl   $0x0,-0xdc(%rbp)
je     1678 <_dywapitch_computeWaveletPitch+0x508>
movsd  -0xd0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1678 <_dywapitch_computeWaveletPitch+0x508>
xorps  %xmm0,%xmm0
ucomisd -0xc8(%rbp),%xmm0
ff
jb     1678 <_dywapitch_computeWaveletPitch+0x508>
movsd  -0x28(%rbp),%xmm0
movaps 0xa25(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     166e <_dywapitch_computeWaveletPitch+0x4fe>
mov    -0x1c(%rbp),%eax
mov    -0xd8(%rbp),%ecx
add    -0xbc(%rbp),%ecx
cmp    %ecx,%eax
jle    1664 <_dywapitch_computeWaveletPitch+0x4f4>
mov    -0x1c(%rbp),%edx
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x60(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
mov    %eax,-0xd8(%rbp)
movl   $0x0,-0xdc(%rbp)
jmp    1669 <_dywapitch_computeWaveletPitch+0x4f9>
jmp    1669 <_dywapitch_computeWaveletPitch+0x4f9>
jmp    1673 <_dywapitch_computeWaveletPitch+0x503>
jmp    1673 <_dywapitch_computeWaveletPitch+0x503>
jmp    1678 <_dywapitch_computeWaveletPitch+0x508>
jmp    167d <_dywapitch_computeWaveletPitch+0x50d>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    145b <_dywapitch_computeWaveletPitch+0x2eb>
cmpl   $0x0,-0x5c(%rbp)
jne    16b4 <_dywapitch_computeWaveletPitch+0x544>
cmpl   $0x0,-0x60(%rbp)
jne    16b4 <_dywapitch_computeWaveletPitch+0x544>
jmp    1b80 <_dywapitch_computeWaveletPitch+0xa10>
mov    -0x48(%rbp),%rdi
movslq -0x10(%rbp),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    1769 <_dywapitch_computeWaveletPitch+0x5f9>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1756 <_dywapitch_computeWaveletPitch+0x5e6>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    1743 <_dywapitch_computeWaveletPitch+0x5d3>
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x50(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
sub    (%rax,%rcx,4),%edi
mov    $0x0,%al
call   1050 <_iabs@plt>
mov    %eax,-0xe4(%rbp)
mov    -0x48(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x48(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1748 <_dywapitch_computeWaveletPitch+0x5d8>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    16e1 <_dywapitch_computeWaveletPitch+0x571>
jmp    175b <_dywapitch_computeWaveletPitch+0x5eb>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16ce <_dywapitch_computeWaveletPitch+0x55e>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    180b <_dywapitch_computeWaveletPitch+0x69b>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    17f8 <_dywapitch_computeWaveletPitch+0x688>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    17e5 <_dywapitch_computeWaveletPitch+0x675>
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x58(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
sub    (%rax,%rcx,4),%edi
mov    $0x0,%al
call   1050 <_iabs@plt>
mov    %eax,-0xe4(%rbp)
mov    -0x48(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x48(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    17ea <_dywapitch_computeWaveletPitch+0x67a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1783 <_dywapitch_computeWaveletPitch+0x613>
jmp    17fd <_dywapitch_computeWaveletPitch+0x68d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1770 <_dywapitch_computeWaveletPitch+0x600>
movl   $0xffffffff,-0xe8(%rbp)
ff ff ff
movl   $0xffffffff,-0xec(%rbp)
ff ff ff
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1916 <_dywapitch_computeWaveletPitch+0x7a6>
movl   $0x0,-0xf0(%rbp)
xor    %eax,%eax
sub    -0xbc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jg     18a3 <_dywapitch_computeWaveletPitch+0x733>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    $0x0,%eax
jl     1890 <_dywapitch_computeWaveletPitch+0x720>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1890 <_dywapitch_computeWaveletPitch+0x720>
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0xf0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
jmp    1895 <_dywapitch_computeWaveletPitch+0x725>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1847 <_dywapitch_computeWaveletPitch+0x6d7>
mov    -0xf0(%rbp),%eax
cmp    -0xec(%rbp),%eax
jne    18d7 <_dywapitch_computeWaveletPitch+0x767>
mov    -0x1c(%rbp),%eax
mov    -0xe8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    18d2 <_dywapitch_computeWaveletPitch+0x762>
mov    -0x1c(%rbp),%eax
mov    %eax,-0xe8(%rbp)
jmp    1903 <_dywapitch_computeWaveletPitch+0x793>
mov    -0xf0(%rbp),%eax
cmp    -0xec(%rbp),%eax
jle    18fe <_dywapitch_computeWaveletPitch+0x78e>
mov    -0xf0(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0xe8(%rbp)
jmp    1903 <_dywapitch_computeWaveletPitch+0x793>
jmp    1908 <_dywapitch_computeWaveletPitch+0x798>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1826 <_dywapitch_computeWaveletPitch+0x6b6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xor    %eax,%eax
sub    -0xbc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jg     19e4 <_dywapitch_computeWaveletPitch+0x874>
mov    -0xe8(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    $0x0,%eax
jl     19d1 <_dywapitch_computeWaveletPitch+0x861>
mov    -0xe8(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19d1 <_dywapitch_computeWaveletPitch+0x861>
mov    -0x48(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x104(%rbp)
cmpl   $0x0,-0x104(%rbp)
jle    19cc <_dywapitch_computeWaveletPitch+0x85c>
cvtsi2sdl -0x104(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xe8(%rbp),%eax
add    -0x20(%rbp),%eax
imul   -0x104(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    19d1 <_dywapitch_computeWaveletPitch+0x861>
jmp    19d6 <_dywapitch_computeWaveletPitch+0x866>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1937 <_dywapitch_computeWaveletPitch+0x7c7>
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0x600(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ab2 <_dywapitch_computeWaveletPitch+0x942>
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movaps 0x5e0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
mov    -0xbc(%rbp),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm0
ucomisd %xmm1,%xmm0
jb     1aad <_dywapitch_computeWaveletPitch+0x93d>
mov    -0xac(%rbp),%edi
sub    $0x1,%edi
mov    $0x0,%al
call   1090 <_2power@plt>
cvtsi2sd %eax,%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
movsd  0x579(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
jmp    1b80 <_dywapitch_computeWaveletPitch+0xa10>
jmp    1ab2 <_dywapitch_computeWaveletPitch+0x942>
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x64(%rbp),%eax
jl     1ae5 <_dywapitch_computeWaveletPitch+0x975>
jmp    1b80 <_dywapitch_computeWaveletPitch+0xa10>
cmpl   $0x2,-0x3c(%rbp)
jge    1af4 <_dywapitch_computeWaveletPitch+0x984>
jmp    1b80 <_dywapitch_computeWaveletPitch+0xa10>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x3c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x11c(%rbp),%eax
cmp    %ecx,%eax
jge    1b6d <_dywapitch_computeWaveletPitch+0x9fd>
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x4da(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1afb <_dywapitch_computeWaveletPitch+0x98b>
mov    -0x3c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
jmp    13d3 <_dywapitch_computeWaveletPitch+0x263>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x18(%rbp),%xmm0
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_dywapitch_computeWaveletPitch>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %esi,%r12d
mov    %rdi,%r15
mov    %edx,%edi
xor    %eax,%eax
call   1080 <_floor_power2@plt>
mov    %eax,%ebp
movslq %eax,%rbx
lea    0x0(,%rbx,8),%r13
mov    %r13,%rdi
call   1070 <malloc@plt>
mov    %rax,%r14
movslq %r12d,%rax
mov    %ebp,%r12d
lea    (%r15,%rax,8),%rsi
mov    %r14,%rdi
mov    %r13,%rdx
call   1060 <memcpy@plt>
shl    $0x2,%rbx
mov    %rbx,%rdi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    %rbx,%rdi
call   1070 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %rbx,0x70(%rsp)
mov    %rbx,%rdi
call   1070 <malloc@plt>
mov    %rax,%r13
xorpd  %xmm3,%xmm3
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
test   %r12d,%r12d
jle    128c <_dywapitch_computeWaveletPitch+0x11c>
mov    %r12d,%eax
cmp    $0x1,%r12d
jne    1214 <_dywapitch_computeWaveletPitch+0xa4>
xorpd  %xmm5,%xmm5
xor    %ecx,%ecx
xorpd  %xmm4,%xmm4
xorpd  %xmm3,%xmm3
jmp    126a <_dywapitch_computeWaveletPitch+0xfa>
mov    %eax,%edx
and    $0xfffffffe,%edx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
xorpd  %xmm4,%xmm4
xorpd  %xmm3,%xmm3
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm1
movsd  0x8(%r14,%rcx,8),%xmm5
addsd  %xmm1,%xmm3
movapd %xmm1,%xmm2
maxsd  %xmm4,%xmm2
minsd  %xmm0,%xmm1
addsd  %xmm5,%xmm3
movapd %xmm5,%xmm4
maxsd  %xmm2,%xmm4
minsd  %xmm1,%xmm5
add    $0x2,%rcx
movapd %xmm5,%xmm0
cmp    %rcx,%rdx
jne    1230 <_dywapitch_computeWaveletPitch+0xc0>
test   $0x1,%al
je     128c <_dywapitch_computeWaveletPitch+0x11c>
movsd  (%r14,%rcx,8),%xmm0
addsd  %xmm0,%xmm3
movapd %xmm0,%xmm1
maxsd  %xmm4,%xmm1
minsd  %xmm5,%xmm0
movapd %xmm1,%xmm4
movapd %xmm0,%xmm5
movapd %xmm5,0x10(%rsp)
movsd  %xmm4,0x40(%rsp)
movsd  %xmm3,0x48(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x38(%rsp)
xor    %edi,%edi
xor    %eax,%eax
call   1090 <_2power@plt>
cmp    $0x2,%r12d
jge    12ee <_dywapitch_computeWaveletPitch+0x17e>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
movsd  0x38(%rsp),%xmm0
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movsd  0x48(%rsp),%xmm6
divsd  %xmm0,%xmm6
movapd 0x10(%rsp),%xmm0
subsd  %xmm6,%xmm0
xorpd  0xcee(%rip),%xmm0
movsd  0x40(%rsp),%xmm8
subsd  %xmm6,%xmm8
maxsd  %xmm0,%xmm8
mulsd  0xcf4(%rip),%xmm8
mov    %r14,%rcx
add    $0x18,%rcx
mov    %rcx,0x58(%rsp)
movsd  0xce7(%rip),%xmm9
movsd  0xcf7(%rip),%xmm7
xorpd  %xmm5,%xmm5
mov    $0x1,%r8d
movl   $0x0,0x24(%rsp)
mov    %r12d,%ebx
mov    %r14,0x68(%rsp)
mov    %r13,0x60(%rsp)
mov    %r12d,0x54(%rsp)
movsd  %xmm5,0x38(%rsp)
movsd  %xmm6,0x48(%rsp)
movsd  %xmm8,0x40(%rsp)
jmp    13ca <_dywapitch_computeWaveletPitch+0x25a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edi,0x24(%rsp)
xor    %eax,%eax
call   1090 <_2power@plt>
cmp    $0x4,%ebp
xorpd  %xmm5,%xmm5
movsd  0x48(%rsp),%xmm6
movsd  0x40(%rsp),%xmm8
movsd  0xc89(%rip),%xmm7
mov    $0x1,%r8d
movsd  0x10(%rsp),%xmm9
jl     12b7 <_dywapitch_computeWaveletPitch+0x147>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xc57(%rip),%xmm0
cmp    $0x3,%ebx
jl     12b7 <_dywapitch_computeWaveletPitch+0x147>
mov    %ebx,%ebp
movsd  0xc4c(%rip),%xmm1
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%eax
mov    %rax,0x10(%rsp)
movsd  0x8(%r14),%xmm0
mov    $0xfff0bdc0,%ecx
xor    %edx,%edx
mov    $0x2,%eax
xor    %ebx,%ebx
mov    $0xfff0bdc0,%esi
movapd %xmm7,%xmm1
xor    %r12d,%r12d
movl   $0x0,0xc(%rsp)
jmp    143d <_dywapitch_computeWaveletPitch+0x2cd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
cmp    %rax,%rbp
je     1540 <_dywapitch_computeWaveletPitch+0x3d0>
movapd %xmm0,%xmm4
movsd  (%r14,%rax,8),%xmm0
movapd %xmm0,%xmm2
subsd  %xmm6,%xmm2
ucomisd %xmm5,%xmm2
mov    %ebx,%edi
cmova  %r8d,%ebx
subsd  %xmm6,%xmm4
ucomisd %xmm4,%xmm5
cmovb  %edi,%ebx
ucomisd %xmm2,%xmm5
mov    %edx,%edi
cmova  %r8d,%edx
ucomisd %xmm5,%xmm4
cmovb  %edi,%edx
movapd %xmm1,%xmm3
movapd %xmm2,%xmm1
subsd  %xmm4,%xmm1
ucomisd %xmm7,%xmm3
jbe    1430 <_dywapitch_computeWaveletPitch+0x2c0>
test   %edx,%edx
je     14d1 <_dywapitch_computeWaveletPitch+0x361>
ucomisd %xmm3,%xmm5
jbe    14d1 <_dywapitch_computeWaveletPitch+0x361>
ucomisd %xmm5,%xmm1
jb     14d1 <_dywapitch_computeWaveletPitch+0x361>
movapd %xmm2,%xmm4
andpd  0xb6d(%rip),%xmm4
ucomisd %xmm8,%xmm4
mov    $0x1,%edx
jb     14d1 <_dywapitch_computeWaveletPitch+0x361>
mov    0x10(%rsp),%rdi
add    %esi,%edi
movslq %edi,%rdi
cmp    %rdi,%rax
jle    14d1 <_dywapitch_computeWaveletPitch+0x361>
movslq %r12d,%rdx
add    $0x1,%r12d
mov    0x30(%rsp),%rsi
mov    %eax,(%rsi,%rdx,4)
xor    %edx,%edx
mov    %eax,%esi
test   %ebx,%ebx
je     1430 <_dywapitch_computeWaveletPitch+0x2c0>
ucomisd %xmm5,%xmm3
jbe    1430 <_dywapitch_computeWaveletPitch+0x2c0>
ucomisd %xmm1,%xmm5
jb     1430 <_dywapitch_computeWaveletPitch+0x2c0>
andpd  0xb1b(%rip),%xmm2
ucomisd %xmm8,%xmm2
mov    $0x1,%ebx
jb     1430 <_dywapitch_computeWaveletPitch+0x2c0>
mov    0x10(%rsp),%rdi
add    %ecx,%edi
movslq %edi,%rdi
cmp    %rdi,%rax
jle    1430 <_dywapitch_computeWaveletPitch+0x2c0>
mov    0xc(%rsp),%edi
movslq %edi,%rcx
add    $0x1,%edi
mov    %edi,0xc(%rsp)
mov    %eax,0x0(%r13,%rcx,4)
xor    %ebx,%ebx
mov    %eax,%ecx
jmp    1430 <_dywapitch_computeWaveletPitch+0x2c0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12d,%eax
or     0xc(%rsp),%eax
je     12b7 <_dywapitch_computeWaveletPitch+0x147>
movsd  %xmm9,0x28(%rsp)
mov    %r15,%rdi
xor    %esi,%esi
mov    0x70(%rsp),%rdx
call   1040 <memset@plt>
test   %r12d,%r12d
jle    15e0 <_dywapitch_computeWaveletPitch+0x470>
mov    %r12d,%r14d
mov    %r14,%r13
neg    %r13
mov    $0x1,%ebx
jmp    1592 <_dywapitch_computeWaveletPitch+0x422>
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%r13,1),%rax
add    $0x1,%rax
add    $0x1,%rbx
cmp    $0x1,%rax
je     15e0 <_dywapitch_computeWaveletPitch+0x470>
cmp    %r14,%rbx
jae    15b1 <_dywapitch_computeWaveletPitch+0x441>
mov    0x30(%rsp),%rax
mov    -0x4(%rax,%rbx,4),%edi
sub    (%rax,%rbx,4),%edi
xor    %eax,%eax
call   1050 <_iabs@plt>
cltq
addl   $0x1,(%r15,%rax,4)
lea    0x1(%rbx),%eax
cmp    %eax,%r12d
jle    1580 <_dywapitch_computeWaveletPitch+0x410>
mov    0x30(%rsp),%rax
mov    -0x4(%rax,%rbx,4),%edi
sub    0x4(%rax,%rbx,4),%edi
xor    %eax,%eax
call   1050 <_iabs@plt>
cltq
addl   $0x1,(%r15,%rax,4)
jmp    1580 <_dywapitch_computeWaveletPitch+0x410>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x0,0xc(%rsp)
mov    0x60(%rsp),%r13
movsd  0xa5e(%rip),%xmm2
movsd  0x28(%rsp),%xmm3
jle    1680 <_dywapitch_computeWaveletPitch+0x510>
mov    0xc(%rsp),%r12d
mov    %r12,%r14
neg    %r14
mov    $0x1,%ebx
jmp    1622 <_dywapitch_computeWaveletPitch+0x4b2>
lea    (%r14,%rbx,1),%rax
add    $0x1,%rax
add    $0x1,%rbx
cmp    $0x1,%rax
je     1680 <_dywapitch_computeWaveletPitch+0x510>
cmp    %r12,%rbx
jae    164d <_dywapitch_computeWaveletPitch+0x4dd>
mov    -0x4(%r13,%rbx,4),%edi
sub    0x0(%r13,%rbx,4),%edi
xor    %eax,%eax
call   1050 <_iabs@plt>
movsd  0x28(%rsp),%xmm3
movsd  0xa0a(%rip),%xmm2
cltq
addl   $0x1,(%r15,%rax,4)
lea    0x1(%rbx),%eax
cmp    %eax,0xc(%rsp)
jle    1610 <_dywapitch_computeWaveletPitch+0x4a0>
mov    -0x4(%r13,%rbx,4),%edi
sub    0x4(%r13,%rbx,4),%edi
xor    %eax,%eax
call   1050 <_iabs@plt>
movsd  0x28(%rsp),%xmm3
movsd  0x9db(%rip),%xmm2
cltq
addl   $0x1,(%r15,%rax,4)
jmp    1610 <_dywapitch_computeWaveletPitch+0x4a0>
xchg   %ax,%ax
test   %ebp,%ebp
jle    1760 <_dywapitch_computeWaveletPitch+0x5f0>
mov    0x10(%rsp),%rax
mov    %eax,%r14d
neg    %r14d
mov    %eax,%r10d
neg    %r10d
mov    %eax,%r11d
cmovns %r10d,%r11d
lea    (%rax,%r11,1),%r9d
add    $0x1,%r9d
mov    %r9d,%eax
and    $0xfffffffe,%eax
mov    %eax,0xc(%rsp)
xor    %ebx,%ebx
mov    $0xffffffff,%r12d
mov    $0x1,%esi
mov    $0xffffffff,%eax
jmp    16e5 <_dywapitch_computeWaveletPitch+0x575>
cs nopw 0x0(%rax,%rax,1)
cmovg  %ebx,%eax
cmovg  %ecx,%r12d
add    $0x1,%ebx
add    $0x1,%esi
cmp    %ebp,%ebx
je     1765 <_dywapitch_computeWaveletPitch+0x5f5>
mov    $0x0,%ecx
cmpl   $0x0,0x10(%rsp)
js     1710 <_dywapitch_computeWaveletPitch+0x5a0>
xor    %ecx,%ecx
mov    %r14d,%edx
cmp    %r10d,%r11d
jne    1720 <_dywapitch_computeWaveletPitch+0x5b0>
test   $0x1,%r9b
je     1710 <_dywapitch_computeWaveletPitch+0x5a0>
add    %ebx,%edx
js     1710 <_dywapitch_computeWaveletPitch+0x5a0>
cmp    %ebp,%edx
jge    1710 <_dywapitch_computeWaveletPitch+0x5a0>
mov    %edx,%edx
add    (%r15,%rdx,4),%ecx
nop
cmp    %r12d,%ecx
jne    16d0 <_dywapitch_computeWaveletPitch+0x560>
lea    (%rax,%rax,1),%ecx
cmp    %ecx,%ebx
cmove  %ebx,%eax
jmp    16d7 <_dywapitch_computeWaveletPitch+0x567>
nop
xor    %ecx,%ecx
mov    0xc(%rsp),%r8d
mov    %r14d,%edx
jmp    1739 <_dywapitch_computeWaveletPitch+0x5c9>
nopl   0x0(%rax)
add    $0x2,%edx
add    $0xfffffffe,%r8d
je     16fb <_dywapitch_computeWaveletPitch+0x58b>
mov    %ebx,%edi
add    %edx,%edi
js     1749 <_dywapitch_computeWaveletPitch+0x5d9>
cmp    %ebp,%edi
jge    1749 <_dywapitch_computeWaveletPitch+0x5d9>
mov    %edi,%edi
add    (%r15,%rdi,4),%ecx
mov    %esi,%edi
add    %edx,%edi
js     1730 <_dywapitch_computeWaveletPitch+0x5c0>
cmp    %ebp,%edi
jge    1730 <_dywapitch_computeWaveletPitch+0x5c0>
mov    %edi,%edi
add    (%r15,%rdi,4),%ecx
jmp    1730 <_dywapitch_computeWaveletPitch+0x5c0>
nopl   0x0(%rax,%rax,1)
mov    $0xffffffff,%eax
movsd  0x8db(%rip),%xmm4
cmpl   $0x0,0x10(%rsp)
mov    0x68(%rsp),%r14
mov    0x54(%rsp),%r12d
mov    0x24(%rsp),%edi
js     17e4 <_dywapitch_computeWaveletPitch+0x674>
mov    0x10(%rsp),%rdx
lea    (%rdx,%rdx,1),%ecx
add    $0x1,%ecx
sub    %edx,%eax
xorpd  %xmm0,%xmm0
xorpd  %xmm4,%xmm4
jmp    17a8 <_dywapitch_computeWaveletPitch+0x638>
nopl   0x0(%rax)
add    $0x1,%eax
add    $0xffffffff,%ecx
je     17e0 <_dywapitch_computeWaveletPitch+0x670>
test   %eax,%eax
js     17a0 <_dywapitch_computeWaveletPitch+0x630>
cmp    %r12d,%eax
jge    17a0 <_dywapitch_computeWaveletPitch+0x630>
mov    %eax,%edx
mov    (%r15,%rdx,4),%edx
test   %edx,%edx
jle    17a0 <_dywapitch_computeWaveletPitch+0x630>
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
addsd  %xmm1,%xmm0
imul   %eax,%edx
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
addsd  %xmm1,%xmm4
jmp    17a0 <_dywapitch_computeWaveletPitch+0x630>
cs nopw 0x0(%rax,%rax,1)
divsd  %xmm0,%xmm4
ucomisd 0x83c(%rip),%xmm3
jbe    181a <_dywapitch_computeWaveletPitch+0x6aa>
movapd %xmm4,%xmm0
addsd  %xmm4,%xmm0
subsd  %xmm3,%xmm0
andpd  0x80e(%rip),%xmm0
mov    0x10(%rsp),%rax
add    %eax,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
ucomisd %xmm0,%xmm1
jae    18d2 <_dywapitch_computeWaveletPitch+0x762>
cmp    $0x5,%edi
je     12b7 <_dywapitch_computeWaveletPitch+0x147>
add    $0x1,%edi
cmp    $0x1,%ebp
jle    18c6 <_dywapitch_computeWaveletPitch+0x756>
mov    %ebp,%ebx
shr    $0x1f,%ebx
add    %ebp,%ebx
sar    %ebx
mov    %ebx,%eax
mov    %ebp,%ecx
and    $0xfffffffe,%ecx
cmp    $0x2,%ecx
jne    1850 <_dywapitch_computeWaveletPitch+0x6e0>
xor    %ecx,%ecx
jmp    1895 <_dywapitch_computeWaveletPitch+0x725>
nopl   0x0(%rax,%rax,1)
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    0x58(%rsp),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  -0x18(%rsi),%xmm0
addsd  -0x10(%rsi),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  -0x8(%rsi),%xmm0
addsd  (%rsi),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
add    $0x2,%rcx
add    $0x20,%rsi
cmp    %rcx,%rdx
jne    1860 <_dywapitch_computeWaveletPitch+0x6f0>
movsd  %xmm4,0x10(%rsp)
test   $0x1,%al
je     1390 <_dywapitch_computeWaveletPitch+0x220>
mov    %rcx,%rax
shl    $0x4,%rax
movsd  (%r14,%rax,1),%xmm0
addsd  0x8(%r14,%rax,1),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
jmp    1390 <_dywapitch_computeWaveletPitch+0x220>
xor    %eax,%eax
call   1090 <_2power@plt>
jmp    12b7 <_dywapitch_computeWaveletPitch+0x147>
add    $0xffffffff,%edi
xor    %eax,%eax
call   1090 <_2power@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x28(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x743(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rsp)
jmp    12b7 <_dywapitch_computeWaveletPitch+0x147>

LLVM IR (-O0):
define double @_dywapitch_computeWaveletPitch(double* %0, i32 %1, i32 %2) {
%4 = alloca double*
%5 = alloca i32
%6 = alloca i32
%7 = alloca double
%8 = alloca i32
%9 = alloca i32
%10 = alloca double
%11 = alloca double
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32*
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca double
%21 = alloca i32
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca i32
%29 = alloca double
%30 = alloca i32
%31 = alloca double
%32 = alloca double
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca double
%42 = alloca double
%43 = alloca i32
%44 = alloca double
store double* %0, double** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store double 0.000000e+00, double* %7
%45 = load i32, i32* %6
%46 = call i32 (i32, ...) bitcast (i32 (...)* @_floor_power2 to i32 (i32, ...)*)(i32 %45)
store i32 %46, i32* %6
%47 = load i32, i32* %6
%48 = sext i32 %47 to i64
%49 = mul i64 8, %48
%50 = call i8* @malloc(i64 %49)
%51 = bitcast i8* %50 to double*
store double* %51, double** %12
%52 = load double*, double** %12
%53 = bitcast double* %52 to i8*
%54 = load double*, double** %4
%55 = load i32, i32* %5
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %54, i64 %56
%58 = bitcast double* %57 to i8*
%59 = load i32, i32* %6
%60 = sext i32 %59 to i64
%61 = mul i64 8, %60
%62 = load i32, i32* %6
store i32 %62, i32* %13
%63 = load i32, i32* %6
%64 = sext i32 %63 to i64
%65 = mul i64 4, %64
%66 = call i8* @malloc(i64 %65)
%67 = bitcast i8* %66 to i32*
store i32* %67, i32** %14
%68 = load i32, i32* %6
%69 = sext i32 %68 to i64
%70 = mul i64 4, %69
%71 = call i8* @malloc(i64 %70)
%72 = bitcast i8* %71 to i32*
store i32* %72, i32** %15
%73 = load i32, i32* %6
%74 = sext i32 %73 to i64
%75 = mul i64 4, %74
%76 = call i8* @malloc(i64 %75)
%77 = bitcast i8* %76 to i32*
store i32* %77, i32** %16
store i32 6, i32* %19
store double 3.000000e+03, double* %20
store i32 3, i32* %21
store double 7.500000e-01, double* %22
store double 0.000000e+00, double* %24
store double 0.000000e+00, double* %25
store double 0.000000e+00, double* %26
store i32 0, i32* %8
br label %78
78: ; preds = %103, %3
%79 = load i32, i32* %8
%80 = load i32, i32* %6
%81 = icmp slt i32 %79, %80
br i1 %81, label %82, label %106
82: ; preds = %78
%83 = load double*, double** %12
%84 = load i32, i32* %8
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %83, i64 %85
%87 = load double, double* %86
store double %87, double* %10
%88 = load double, double* %24
%89 = load double, double* %10
%90 = fadd double %88, %89
store double %90, double* %24
%91 = load double, double* %10
%92 = load double, double* %25
%93 = fcmp ogt double %91, %92
br i1 %93, label %94, label %96
94: ; preds = %82
%95 = load double, double* %10
store double %95, double* %25
br label %96
96: ; preds = %94, %82
%97 = load double, double* %10
%98 = load double, double* %26
%99 = fcmp olt double %97, %98
br i1 %99, label %100, label %102
100: ; preds = %96
%101 = load double, double* %10
store double %101, double* %26
br label %102
102: ; preds = %100, %96
br label %103
103: ; preds = %102
%104 = load i32, i32* %8
%105 = add nsw i32 %104, 1
store i32 %105, i32* %8
br label %78
106: ; preds = %78
%107 = load double, double* %24
%108 = load i32, i32* %6
%109 = sitofp i32 %108 to double
%110 = fdiv double %107, %109
store double %110, double* %24
%111 = load double, double* %25
%112 = load double, double* %24
%113 = fsub double %111, %112
store double %113, double* %25
%114 = load double, double* %26
%115 = load double, double* %24
%116 = fsub double %114, %115
store double %116, double* %26
%117 = load double, double* %25
%118 = load double, double* %26
%119 = fneg double %118
%120 = fcmp ogt double %117, %119
br i1 %120, label %121, label %123
121: ; preds = %106
%122 = load double, double* %25
br label %126
123: ; preds = %106
%124 = load double, double* %26
%125 = fneg double %124
br label %126
126: ; preds = %123, %121
%127 = phi double [ %122, %121 ], [ %125, %123 ]
store double %127, double* %27
%128 = load double, double* %27
%129 = load double, double* %22
%130 = fmul double %128, %129
store double %130, double* %23
store i32 0, i32* %28
store double -1.000000e+00, double* %29
br label %131
131: ; preds = %126, %536
%132 = load i32, i32* %28
%133 = call i32 (i32, ...) bitcast (i32 (...)* @_2power to i32 (i32, ...)*)(i32 %132)
%134 = sitofp i32 %133 to double
%135 = load double, double* %20
%136 = fmul double %134, %135
%137 = fdiv double 4.410000e+04, %136
%138 = fptosi double %137 to i32
store i32 %138, i32* %30
%139 = load i32, i32* %13
%140 = icmp slt i32 %139, 2
br i1 %140, label %141, label %142
141: ; preds = %131
br label %539
142: ; preds = %131
store double -1.000000e+03, double* %32
store i32 0, i32* %18
store i32 0, i32* %17
store i32 -1000000, i32* %33
store i32 -1000000, i32* %34
store i32 0, i32* %35
store i32 0, i32* %36
store i32 2, i32* %8
br label %143
143: ; preds = %249, %142
%144 = load i32, i32* %8
%145 = load i32, i32* %13
%146 = icmp slt i32 %144, %145
br i1 %146, label %147, label %252
147: ; preds = %143
%148 = load double*, double** %12
%149 = load i32, i32* %8
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %148, i64 %150
%152 = load double, double* %151
%153 = load double, double* %24
%154 = fsub double %152, %153
store double %154, double* %10
%155 = load double*, double** %12
%156 = load i32, i32* %8
%157 = sub nsw i32 %156, 1
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %155, i64 %158
%160 = load double, double* %159
%161 = load double, double* %24
%162 = fsub double %160, %161
store double %162, double* %11
%163 = load double, double* %11
%164 = fcmp ole double %163, 0.000000e+00
br i1 %164, label %165, label %169
165: ; preds = %147
%166 = load double, double* %10
%167 = fcmp ogt double %166, 0.000000e+00
br i1 %167, label %168, label %169
168: ; preds = %165
store i32 1, i32* %35
br label %169
169: ; preds = %168, %165, %147
%170 = load double, double* %11
%171 = fcmp oge double %170, 0.000000e+00
br i1 %171, label %172, label %176
172: ; preds = %169
%173 = load double, double* %10
%174 = fcmp olt double %173, 0.000000e+00
br i1 %174, label %175, label %176
175: ; preds = %172
store i32 1, i32* %36
br label %176
176: ; preds = %175, %172, %169
%177 = load double, double* %10
%178 = load double, double* %11
%179 = fsub double %177, %178
store double %179, double* %31
%180 = load double, double* %32
%181 = fcmp ogt double %180, -1.000000e+03
br i1 %181, label %182, label %247
182: ; preds = %176
%183 = load i32, i32* %36
%184 = icmp ne i32 %183, 0
br i1 %184, label %185, label %214
185: ; preds = %182
%186 = load double, double* %32
%187 = fcmp olt double %186, 0.000000e+00
br i1 %187, label %188, label %214
188: ; preds = %185
%189 = load double, double* %31
%190 = fcmp oge double %189, 0.000000e+00
br i1 %190, label %191, label %214
191: ; preds = %188
%192 = load double, double* %10
%193 = call double @llvm.fabs.f64(double %192)
%194 = load double, double* %23
%195 = fcmp oge double %193, %194
br i1 %195, label %196, label %212
196: ; preds = %191
%197 = load i32, i32* %8
%198 = load i32, i32* %33
%199 = load i32, i32* %30
%200 = add nsw i32 %198, %199
%201 = icmp sgt i32 %197, %200
br i1 %201, label %202, label %210
202: ; preds = %196
%203 = load i32, i32* %8
%204 = load i32*, i32** %15
%205 = load i32, i32* %17
%206 = add nsw i32 %205, 1
store i32 %206, i32* %17
%207 = sext i32 %205 to i64
%208 = getelementptr inbounds i32, i32* %204, i64 %207
store i32 %203, i32* %208
%209 = load i32, i32* %8
store i32 %209, i32* %33
store i32 0, i32* %36
br label %211
210: ; preds = %196
br label %211
211: ; preds = %210, %202
br label %213
212: ; preds = %191
br label %213
213: ; preds = %212, %211
br label %214
214: ; preds = %213, %188, %185, %182
%215 = load i32, i32* %35
%216 = icmp ne i32 %215, 0
br i1 %216, label %217, label %246
217: ; preds = %214
%218 = load double, double* %32
%219 = fcmp ogt double %218, 0.000000e+00
br i1 %219, label %220, label %246
220: ; preds = %217
%221 = load double, double* %31
%222 = fcmp ole double %221, 0.000000e+00
br i1 %222, label %223, label %246
223: ; preds = %220
%224 = load double, double* %10
%225 = call double @llvm.fabs.f64(double %224)
%226 = load double, double* %23
%227 = fcmp oge double %225, %226
br i1 %227, label %228, label %244
228: ; preds = %223
%229 = load i32, i32* %8
%230 = load i32, i32* %34
%231 = load i32, i32* %30
%232 = add nsw i32 %230, %231
%233 = icmp sgt i32 %229, %232
br i1 %233, label %234, label %242
234: ; preds = %228
%235 = load i32, i32* %8
%236 = load i32*, i32** %16
%237 = load i32, i32* %18
%238 = add nsw i32 %237, 1
store i32 %238, i32* %18
%239 = sext i32 %237 to i64
%240 = getelementptr inbounds i32, i32* %236, i64 %239
store i32 %235, i32* %240
%241 = load i32, i32* %8
store i32 %241, i32* %34
store i32 0, i32* %35
br label %243
242: ; preds = %228
br label %243
243: ; preds = %242, %234
br label %245
244: ; preds = %223
br label %245
245: ; preds = %244, %243
br label %246
246: ; preds = %245, %220, %217, %214
br label %247
247: ; preds = %246, %176
%248 = load double, double* %31
store double %248, double* %32
br label %249
249: ; preds = %247
%250 = load i32, i32* %8
%251 = add nsw i32 %250, 1
store i32 %251, i32* %8
br label %143
252: ; preds = %143
%253 = load i32, i32* %17
%254 = icmp eq i32 %253, 0
br i1 %254, label %255, label %259
255: ; preds = %252
%256 = load i32, i32* %18
%257 = icmp eq i32 %256, 0
br i1 %257, label %258, label %259
258: ; preds = %255
br label %539
259: ; preds = %255, %252
%260 = load i32*, i32** %14
%261 = bitcast i32* %260 to i8*
%262 = load i32, i32* %6
%263 = sext i32 %262 to i64
%264 = mul i64 %263, 4
store i32 0, i32* %8
br label %265
265: ; preds = %310, %259
%266 = load i32, i32* %8
%267 = load i32, i32* %17
%268 = icmp slt i32 %266, %267
br i1 %268, label %269, label %313
269: ; preds = %265
store i32 1, i32* %9
br label %270
270: ; preds = %306, %269
%271 = load i32, i32* %9
%272 = load i32, i32* %21
%273 = icmp slt i32 %271, %272
br i1 %273, label %274, label %309
274: ; preds = %270
%275 = load i32, i32* %8
%276 = load i32, i32* %9
%277 = add nsw i32 %275, %276
%278 = load i32, i32* %17
%279 = icmp slt i32 %277, %278
br i1 %279, label %280, label %305
280: ; preds = %274
%281 = load i32*, i32** %15
%282 = load i32, i32* %8
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds i32, i32* %281, i64 %283
%285 = load i32, i32* %284
%286 = load i32*, i32** %15
%287 = load i32, i32* %8
%288 = load i32, i32* %9
%289 = add nsw i32 %287, %288
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i32, i32* %286, i64 %290
%292 = load i32, i32* %291
%293 = sub nsw i32 %285, %292
%294 = call i32 (i32, ...) bitcast (i32 (...)* @_iabs to i32 (i32, ...)*)(i32 %293)
store i32 %294, i32* %37
%295 = load i32*, i32** %14
%296 = load i32, i32* %37
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i32, i32* %295, i64 %297
%299 = load i32, i32* %298
%300 = add nsw i32 %299, 1
%301 = load i32*, i32** %14
%302 = load i32, i32* %37
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %301, i64 %303
store i32 %300, i32* %304
br label %305
305: ; preds = %280, %274
br label %306
306: ; preds = %305
%307 = load i32, i32* %9
%308 = add nsw i32 %307, 1
store i32 %308, i32* %9
br label %270
309: ; preds = %270
br label %310
310: ; preds = %309
%311 = load i32, i32* %8
%312 = add nsw i32 %311, 1
store i32 %312, i32* %8
br label %265
313: ; preds = %265
store i32 0, i32* %8
br label %314
314: ; preds = %359, %313
%315 = load i32, i32* %8
%316 = load i32, i32* %18
%317 = icmp slt i32 %315, %316
br i1 %317, label %318, label %362
318: ; preds = %314
store i32 1, i32* %9
br label %319
319: ; preds = %355, %318
%320 = load i32, i32* %9
%321 = load i32, i32* %21
%322 = icmp slt i32 %320, %321
br i1 %322, label %323, label %358
323: ; preds = %319
%324 = load i32, i32* %8
%325 = load i32, i32* %9
%326 = add nsw i32 %324, %325
%327 = load i32, i32* %18
%328 = icmp slt i32 %326, %327
br i1 %328, label %329, label %354
329: ; preds = %323
%330 = load i32*, i32** %16
%331 = load i32, i32* %8
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds i32, i32* %330, i64 %332
%334 = load i32, i32* %333
%335 = load i32*, i32** %16
%336 = load i32, i32* %8
%337 = load i32, i32* %9
%338 = add nsw i32 %336, %337
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i32, i32* %335, i64 %339
%341 = load i32, i32* %340
%342 = sub nsw i32 %334, %341
%343 = call i32 (i32, ...) bitcast (i32 (...)* @_iabs to i32 (i32, ...)*)(i32 %342)
store i32 %343, i32* %37
%344 = load i32*, i32** %14
%345 = load i32, i32* %37
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i32, i32* %344, i64 %346
%348 = load i32, i32* %347
%349 = add nsw i32 %348, 1
%350 = load i32*, i32** %14
%351 = load i32, i32* %37
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i32, i32* %350, i64 %352
store i32 %349, i32* %353
br label %354
354: ; preds = %329, %323
br label %355
355: ; preds = %354
%356 = load i32, i32* %9
%357 = add nsw i32 %356, 1
store i32 %357, i32* %9
br label %319
358: ; preds = %319
br label %359
359: ; preds = %358
%360 = load i32, i32* %8
%361 = add nsw i32 %360, 1
store i32 %361, i32* %8
br label %314
362: ; preds = %314
store i32 -1, i32* %38
store i32 -1, i32* %39
store i32 0, i32* %8
br label %363
363: ; preds = %420, %362
%364 = load i32, i32* %8
%365 = load i32, i32* %13
%366 = icmp slt i32 %364, %365
br i1 %366, label %367, label %423
367: ; preds = %363
store i32 0, i32* %40
%368 = load i32, i32* %30
%369 = sub nsw i32 0, %368
store i32 %369, i32* %9
br label %370
370: ; preds = %396, %367
%371 = load i32, i32* %9
%372 = load i32, i32* %30
%373 = icmp sle i32 %371, %372
br i1 %373, label %374, label %399
374: ; preds = %370
%375 = load i32, i32* %8
%376 = load i32, i32* %9
%377 = add nsw i32 %375, %376
%378 = icmp sge i32 %377, 0
br i1 %378, label %379, label %395
379: ; preds = %374
%380 = load i32, i32* %8
%381 = load i32, i32* %9
%382 = add nsw i32 %380, %381
%383 = load i32, i32* %13
%384 = icmp slt i32 %382, %383
br i1 %384, label %385, label %395
385: ; preds = %379
%386 = load i32*, i32** %14
%387 = load i32, i32* %8
%388 = load i32, i32* %9
%389 = add nsw i32 %387, %388
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds i32, i32* %386, i64 %390
%392 = load i32, i32* %391
%393 = load i32, i32* %40
%394 = add nsw i32 %393, %392
store i32 %394, i32* %40
br label %395
395: ; preds = %385, %379, %374
br label %396
396: ; preds = %395
%397 = load i32, i32* %9
%398 = add nsw i32 %397, 1
store i32 %398, i32* %9
br label %370
399: ; preds = %370
%400 = load i32, i32* %40
%401 = load i32, i32* %39
%402 = icmp eq i32 %400, %401
br i1 %402, label %403, label %411
403: ; preds = %399
%404 = load i32, i32* %8
%405 = load i32, i32* %38
%406 = mul nsw i32 2, %405
%407 = icmp eq i32 %404, %406
br i1 %407, label %408, label %410
408: ; preds = %403
%409 = load i32, i32* %8
store i32 %409, i32* %38
br label %410
410: ; preds = %408, %403
br label %419
411: ; preds = %399
%412 = load i32, i32* %40
%413 = load i32, i32* %39
%414 = icmp sgt i32 %412, %413
br i1 %414, label %415, label %418
415: ; preds = %411
%416 = load i32, i32* %40
store i32 %416, i32* %39
%417 = load i32, i32* %8
store i32 %417, i32* %38
br label %418
418: ; preds = %415, %411
br label %419
419: ; preds = %418, %410
br label %420
420: ; preds = %419
%421 = load i32, i32* %8
%422 = add nsw i32 %421, 1
store i32 %422, i32* %8
br label %363
423: ; preds = %363
store double 0.000000e+00, double* %41
store double 0.000000e+00, double* %42
%424 = load i32, i32* %30
%425 = sub nsw i32 0, %424
store i32 %425, i32* %9
br label %426
426: ; preds = %466, %423
%427 = load i32, i32* %9
%428 = load i32, i32* %30
%429 = icmp sle i32 %427, %428
br i1 %429, label %430, label %469
430: ; preds = %426
%431 = load i32, i32* %38
%432 = load i32, i32* %9
%433 = add nsw i32 %431, %432
%434 = icmp sge i32 %433, 0
br i1 %434, label %435, label %465
435: ; preds = %430
%436 = load i32, i32* %38
%437 = load i32, i32* %9
%438 = add nsw i32 %436, %437
%439 = load i32, i32* %6
%440 = icmp slt i32 %438, %439
br i1 %440, label %441, label %465
441: ; preds = %435
%442 = load i32*, i32** %14
%443 = load i32, i32* %38
%444 = load i32, i32* %9
%445 = add nsw i32 %443, %444
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i32, i32* %442, i64 %446
%448 = load i32, i32* %447
store i32 %448, i32* %43
%449 = load i32, i32* %43
%450 = icmp sgt i32 %449, 0
br i1 %450, label %451, label %464
451: ; preds = %441
%452 = load i32, i32* %43
%453 = sitofp i32 %452 to double
%454 = load double, double* %42
%455 = fadd double %454, %453
store double %455, double* %42
%456 = load i32, i32* %38
%457 = load i32, i32* %9
%458 = add nsw i32 %456, %457
%459 = load i32, i32* %43
%460 = mul nsw i32 %458, %459
%461 = sitofp i32 %460 to double
%462 = load double, double* %41
%463 = fadd double %462, %461
store double %463, double* %41
br label %464
464: ; preds = %451, %441
br label %465
465: ; preds = %464, %435, %430
br label %466
466: ; preds = %465
%467 = load i32, i32* %9
%468 = add nsw i32 %467, 1
store i32 %468, i32* %9
br label %426
469: ; preds = %426
%470 = load double, double* %42
%471 = load double, double* %41
%472 = fdiv double %471, %470
store double %472, double* %41
%473 = load double, double* %29
%474 = fcmp ogt double %473, -1.000000e+00
br i1 %474, label %475, label %495
475: ; preds = %469
%476 = load double, double* %41
%477 = load double, double* %29
%478 = fneg double %477
%479 = call double @llvm.fmuladd.f64(double %476, double 2.000000e+00, double %478)
%480 = call double @llvm.fabs.f64(double %479)
store double %480, double* %44
%481 = load double, double* %44
%482 = load i32, i32* %30
%483 = mul nsw i32 2, %482
%484 = sitofp i32 %483 to double
%485 = fcmp ole double %481, %484
br i1 %485, label %486, label %494
486: ; preds = %475
%487 = load i32, i32* %28
%488 = sub nsw i32 %487, 1
%489 = call i32 (i32, ...) bitcast (i32 (...)* @_2power to i32 (i32, ...)*)(i32 %488)
%490 = sitofp i32 %489 to double
%491 = load double, double* %29
%492 = fmul double %490, %491
%493 = fdiv double 4.410000e+04, %492
store double %493, double* %7
br label %539
494: ; preds = %475
br label %495
495: ; preds = %494, %469
%496 = load double, double* %41
store double %496, double* %29
%497 = load i32, i32* %28
%498 = add nsw i32 %497, 1
store i32 %498, i32* %28
%499 = load i32, i32* %28
%500 = load i32, i32* %19
%501 = icmp sge i32 %499, %500
br i1 %501, label %502, label %503
502: ; preds = %495
br label %539
503: ; preds = %495
%504 = load i32, i32* %13
%505 = icmp slt i32 %504, 2
br i1 %505, label %506, label %507
506: ; preds = %503
br label %539
507: ; preds = %503
store i32 0, i32* %8
br label %508
508: ; preds = %533, %507
%509 = load i32, i32* %8
%510 = load i32, i32* %13
%511 = sdiv i32 %510, 2
%512 = icmp slt i32 %509, %511
br i1 %512, label %513, label %536
513: ; preds = %508
%514 = load double*, double** %12
%515 = load i32, i32* %8
%516 = mul nsw i32 2, %515
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds double, double* %514, i64 %517
%519 = load double, double* %518
%520 = load double*, double** %12
%521 = load i32, i32* %8
%522 = mul nsw i32 2, %521
%523 = add nsw i32 %522, 1
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds double, double* %520, i64 %524
%526 = load double, double* %525
%527 = fadd double %519, %526
%528 = fdiv double %527, 2.000000e+00
%529 = load double*, double** %12
%530 = load i32, i32* %8
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds double, double* %529, i64 %531
store double %528, double* %532
br label %533
533: ; preds = %513
%534 = load i32, i32* %8
%535 = add nsw i32 %534, 1
store i32 %535, i32* %8
br label %508
536: ; preds = %508
%537 = load i32, i32* %13
%538 = sdiv i32 %537, 2
store i32 %538, i32* %13
br label %131
539: ; preds = %506, %502, %486, %258, %141
%540 = load i32*, i32** %14
%541 = bitcast i32* %540 to i8*
%542 = load i32*, i32** %15
%543 = bitcast i32* %542 to i8*
%544 = load i32*, i32** %16
%545 = bitcast i32* %544 to i8*
%546 = load double*, double** %12
%547 = bitcast double* %546 to i8*
%548 = load double, double* %7
ret double %548
}

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