LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Sleepwalking[P]world-octave/common.cpp
// Function: InitializeForwardRealFFT(int, ForwardRealFFT*)
void InitializeForwardRealFFT(int fft_size, ForwardRealFFT *forward_real_fft) {
  forward_real_fft->fft_size = fft_size;
  forward_real_fft->waveform = new double[fft_size];
  forward_real_fft->spectrum = new fft_complex[fft_size];
  forward_real_fft->forward_fft = fft_plan_dft_r2c_1d(fft_size,
      forward_real_fft->waveform, forward_real_fft->spectrum, FFT_ESTIMATE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movslq -0x4(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x4(%rbp), %rax
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq -0x58(%rbp), %rdi
movl $0x3, %r8d
callq 0xd3b0
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
leaq -0x58(%rbp), %rsi
movl $0x48, %edx
callq 0x10b0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/common.cpp
// Function: InitializeMinimumPhaseAnalysis(int, MinimumPhaseAnalysis*)
void InitializeMinimumPhaseAnalysis(int fft_size,
    MinimumPhaseAnalysis *minimum_phase) {
  minimum_phase->fft_size = fft_size;
  minimum_phase->log_spectrum = new double[fft_size];
  minimum_phase->minimum_phase_spectrum = new fft_complex[fft_size];
  minimum_phase->cepstrum = new fft_complex[fft_size];
  minimum_phase->inverse_fft = fft_plan_dft_r2c_1d(fft_size,
      minimum_phase->log_spectrum, minimum_phase->cepstrum, FFT_ESTIMATE);
  minimum_phase->forward_fft = fft_plan_dft_1d(fft_size,
      minimum_phase->cepstrum, minimum_phase->minimum_phase_spectrum,
      FFT_FORWARD, FFT_ESTIMATE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movslq -0x4(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x4(%rbp), %rax
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq -0x4(%rbp), %rax
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq -0x58(%rbp), %rdi
movl $0x3, %r8d
callq 0xd3b0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x58(%rbp), %rsi
movl $0x48, %edx
callq 0x10b0
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq -0xa0(%rbp), %rdi
movl $0x1, %r8d
movl $0x3, %r9d
callq 0xcbd0
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
leaq -0xa0(%rbp), %rsi
movl $0x48, %edx
callq 0x10b0
addq $0xa0, %rsp
popq %rbp
retq
// File: Sleepwalking[P]world-octave/common.cpp
// Function: DestroyMinimumPhaseAnalysis(MinimumPhaseAnalysis*)
void DestroyMinimumPhaseAnalysis(MinimumPhaseAnalysis *minimum_phase) {
  fft_destroy_plan(minimum_phase->forward_fft);
  fft_destroy_plan(minimum_phase->inverse_fft);
  delete[] minimum_phase->cepstrum;
  delete[] minimum_phase->log_spectrum;
  delete[] minimum_phase->minimum_phase_spectrum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x68, %rsi
leaq -0x50(%rbp), %rdi
movl $0x48, %edx
callq 0x10b0
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups -0x30(%rbp), %xmm2
movups -0x20(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xda70
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x98(%rbp), %rdi
movl $0x48, %edx
callq 0x10b0
movq -0x58(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0x98(%rbp), %xmm0
movups -0x88(%rbp), %xmm1
movups -0x78(%rbp), %xmm2
movups -0x68(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xda70
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x23d3
movq -0xa0(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x23f4
movq -0xa8(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
je 0x2415
movq -0xb0(%rbp), %rdi
callq 0x1110
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: InitializeDioOption(DioOption*)
void InitializeDioOption(DioOption *option) {
  // You can change default parameters.
  option->channels_in_octave = 2.0;
  option->f0_ceil = world::kCeilF0;
  option->f0_floor = world::kFloorF0;
  option->frame_period = 5;
  // You can use the value from 1 to 12.
  // Default value 11 is for the fs of 44.1 kHz.
  // The lower value you use, the better performance you can obtain.
  option->speed = 1;
  // You can give a positive real number as the threshold.
  // The most strict value is 0, and there is no upper limit.
  // On the other hand, I think that the value from 0.02 to 0.2 is reasonable.
  option->allowed_range = 0.1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x19624(%rip), %xmm0    # 0x1c008
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movsd 0x196a3(%rip), %xmm0    # 0x1c098
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x1968a(%rip), %xmm0    # 0x1c090
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x19672(%rip), %xmm0    # 0x1c088
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
movsd 0x1964e(%rip), %xmm0    # 0x1c080
movsd %xmm0, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: (anonymous namespace)::GetBestF0Contour(int, double**, double**, int, double*)
void GetBestF0Contour(int f0_length, double **f0_candidate_map,
    double **f0_stability_map, int number_of_bands, double *best_f0_contour) {
  double tmp;
  for (int i = 0; i < f0_length; ++i) {
    tmp = f0_stability_map[0][i];
    best_f0_contour[i] = f0_candidate_map[0][i];
    for (int j = 1; j < number_of_bands; ++j) {
      if (tmp > f0_stability_map[j][i]) {
        tmp = f0_stability_map[j][i];
        best_f0_contour[i] = f0_candidate_map[j][i];
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x317f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x316f
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x3162
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x3164
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3102
jmp 0x3171
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x30bd
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: (anonymous namespace)::CalculateRawEvent(double, double, double (*) [2], int, int, double, double, double*, int, double*, double*)
void CalculateRawEvent(double boundary_f0, double fs, fft_complex *y_spectrum,
    int y_length, int fft_size, double f0_floor, double f0_ceil,
    double *time_axis, int time_axis_length, double *f0_deviations,
    double *f0_candidates) {
  double *filtered_signal = new double[fft_size];
  GetFilteredSignal(matlab_round(fs / boundary_f0 / 2.0), fft_size, y_spectrum,
      y_length, filtered_signal);

  ZeroCrossings zero_crossings = {0};
  GetFourZeroCrossingIntervals(filtered_signal, y_length, fs,
      &zero_crossings);

  GetF0Candidates(&zero_crossings, boundary_f0, f0_floor, f0_ceil,
      time_axis, time_axis_length, f0_candidates, f0_deviations);

  DestroyZeroCrossings(&zero_crossings);
  delete[] filtered_signal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x10(%rbp), %rax
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x3c(%rbp)
movq %r9, -0x48(%rbp)
movslq -0x20(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, -0x50(%rbp)
movsd -0x10(%rbp), %xmm0
divsd -0x8(%rbp), %xmm0
movsd 0x189e4(%rip), %xmm1    # 0x1c008
divsd %xmm1, %xmm0
callq 0x72e0
movl %eax, %edi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x50(%rbp), %r8
callq 0x36d0
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x1080
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %esi
movsd -0x10(%rbp), %xmm0
leaq -0xb0(%rbp), %rdx
callq 0x3c00
movsd -0x8(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movq -0x38(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq 0x10(%rbp), %rcx
movq -0x48(%rbp), %r8
leaq -0xb0(%rbp), %rdi
callq 0x3f40
leaq -0xb0(%rbp), %rdi
callq 0x4170
movq -0x50(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
je 0x36c0
movq -0xb8(%rbp), %rdi
callq 0x1110
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: (anonymous namespace)::DestroyZeroCrossings(ZeroCrossings*)
void DestroyZeroCrossings(ZeroCrossings *zero_crossings) {
  delete[] zero_crossings->negative_interval_locations;
  delete[] zero_crossings->positive_interval_locations;
  delete[] zero_crossings->peak_interval_locations;
  delete[] zero_crossings->dip_interval_locations;
  delete[] zero_crossings->negative_intervals;
  delete[] zero_crossings->positive_intervals;
  delete[] zero_crossings->peak_intervals;
  delete[] zero_crossings->dip_intervals;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x4196
movq -0x10(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x41b1
movq -0x18(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x41cc
movq -0x20(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x41e7
movq -0x28(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4202
movq -0x30(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x421d
movq -0x38(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x4238
movq -0x40(%rbp), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x4253
movq -0x48(%rbp), %rdi
callq 0x1110
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: (anonymous namespace)::FixStep2(double*, int, int, double*)
void FixStep2(double *f0_step1, int f0_length, int voice_range_minimum,
    double *f0_step2) {
  for (int i = 0; i < f0_length; ++i) f0_step2[i] = f0_step1[i];

  int center = (voice_range_minimum - 1) / 2;
  for (int i = center; i < f0_length - center; ++i) {
    for (int j = -center; j <= center; ++j) {
      if (f0_step1[i + j] == 0) {
        f0_step2[i] = 0.0;
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4a16
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x49e9
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0xc(%rbp), %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x4a93
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x4a86
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4a79
jp 0x4a79
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x4a86
jmp 0x4a7b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4a42
jmp 0x4a88
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4a2d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: (anonymous namespace)::CountNumberOfVoicedSections(double*, int, int*, int*, int*, int*)
void CountNumberOfVoicedSections(double *f0_step2, int f0_length,
    int *positive_index, int *negative_index, int *positive_count,
    int *negative_count) {
  *positive_count = *negative_count = 0;
  for (int i = 1; i < f0_length; ++i) {
    if (f0_step2[i] == 0 && f0_step2[i - 1] != 0) {
      negative_index[(*negative_count)++] = i - 1;
    } else {
      if (f0_step2[i - 1] == 0 && f0_step2[i] != 0)
        positive_index[(*positive_count)++] = i;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4b9b
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4b38
jp 0x4b38
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4b19
jp 0x4b19
jmp 0x4b38
movl -0x34(%rbp), %edx
subl $0x1, %edx
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x4b8b
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4b89
jp 0x4b89
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4b6f
jp 0x4b6f
jmp 0x4b89
movl -0x34(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x4b8b
jmp 0x4b8d
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4ad6
popq %rbp
retq
nopl (%rax)
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: (anonymous namespace)::FixStep3(double*, int, double**, int, double, int*, int, double*)
void FixStep3(double *f0_step2, int f0_length, double **f0_candidates,
    int number_of_candidates, double allowed_range, int *negative_index,
    int negative_count, double *f0_step3) {
  for (int i = 0; i < f0_length; i++) f0_step3[i] = f0_step2[i];

  int limit;
  for (int i = 0; i < negative_count; ++i) {
    limit = i == negative_count - 1 ? f0_length - 1 : negative_index[i + 1];
    for (int j = negative_index[i]; j < limit; ++j) {
      f0_step3[j + 1] =
        SelectBestF0(f0_step3[j], f0_step3[j - 1], f0_candidates,
            number_of_candidates, j + 1, allowed_range);
      if (f0_step3[j + 1] == 0) break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4bfb
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4bce
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x4cd9
movl -0x40(%rbp), %eax
movl -0x34(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4c26
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x4c39
movq -0x30(%rbp), %rax
movl -0x40(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x4cc9
movq 0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x44(%rbp), %edx
addl $0x1, %edx
movsd -0x28(%rbp), %xmm2
callq 0x4e20
movq 0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4cbc
jp 0x4cbc
jmp 0x4cc9
jmp 0x4cbe
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4c4d
jmp 0x4ccb
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x4c02
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: (anonymous namespace)::FixStep4(double*, int, double**, int, double, int*, int, double*)
void FixStep4(double *f0_step3, int f0_length, double **f0_candidates,
    int number_of_candidates, double allowed_range, int *positive_index,
    int positive_count, double *f0_step4) {
  for (int i = 0; i < f0_length; ++i) f0_step4[i] = f0_step3[i];

  int limit;
  for (int i = positive_count - 1; i >= 0; --i) {
    limit = i == 0 ? 1 : positive_index[i - 1];
    for (int j = positive_index[i]; j > limit; --j) {
      f0_step4[j - 1] =
        SelectBestF0(f0_step4[j], f0_step4[j + 1], f0_candidates,
            number_of_candidates, j - 1, allowed_range);
      if (f0_step4[j - 1] == 0) break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4d3b
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4d0e
movl -0x34(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jl 0x4e11
cmpl $0x0, -0x40(%rbp)
jne 0x4d5e
movl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x4d71
movq -0x30(%rbp), %rax
movl -0x40(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jle 0x4e01
movq 0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x44(%rbp), %edx
subl $0x1, %edx
movsd -0x28(%rbp), %xmm2
callq 0x4e20
movq 0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4df4
jp 0x4df4
jmp 0x4e01
jmp 0x4df6
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4d85
jmp 0x4e03
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x4d44
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Sleepwalking[P]world-octave/dio.cpp
// Function: (anonymous namespace)::SelectBestF0(double, double, double**, int, int, double)
double SelectBestF0(double current_f0, double past_f0, double **f0_candidates,
    int number_of_candidates, int target_index, double allowed_range) {
  double reference_f0 = (current_f0 * 3.0 - past_f0) / 2.0;

  double minimum_error = fabs(reference_f0 - f0_candidates[0][target_index]);
  double best_f0 = f0_candidates[0][target_index];

  double current_error;
  for (int i = 1; i < number_of_candidates; ++i) {
    current_error = fabs(reference_f0 - f0_candidates[i][target_index]);
    if (current_error < minimum_error) {
      minimum_error = current_error;
      best_f0 = f0_candidates[i][target_index];
    }
  }
  if (fabs(1.0 - best_f0 / reference_f0) > allowed_range)
    return 0.0;
  return best_f0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x17262(%rip), %xmm2    # 0x1c0c8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x17192(%rip), %xmm1    # 0x1c008
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movaps 0x17245(%rip), %xmm1    # 0x1c0e0
pand %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x1, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4f33
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movaps 0x171f7(%rip), %xmm1    # 0x1c0e0
pand %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4f26
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x4f28
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x4ec0
movsd -0x48(%rbp), %xmm1
divsd -0x38(%rbp), %xmm1
movsd 0x170cb(%rip), %xmm0    # 0x1c010
subsd %xmm1, %xmm0
movaps 0x17190(%rip), %xmm1    # 0x1c0e0
pand %xmm1, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x4f65
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4f6f
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/synthesis.cpp
// Function: (anonymous namespace)::GetSpectralEnvelope(double, double, int, double**, int, double*)
void GetSpectralEnvelope(double current_time, double frame_period,
    int f0_length, double **spectrogram, int fft_size,
    double *spectral_envelope) {
  int current_frame_floor =
    MyMin(f0_length - 1, static_cast<int>(floor(current_time / frame_period)));
  int current_frame_ceil =
    MyMin(f0_length - 1, static_cast<int>(ceil(current_time / frame_period)));
  double interpolation = current_time / frame_period - current_frame_floor;

  if (current_frame_floor == current_frame_ceil) {
    for (int i = 0; i <= fft_size / 2; ++i)
      spectral_envelope[i] = spectrogram[current_frame_floor][i];
  } else {
    for (int i = 0; i <= fft_size / 2; ++i)
      spectral_envelope[i] =
        (1.0 - interpolation) * spectrogram[current_frame_floor][i] +
        interpolation * spectrogram[current_frame_ceil][i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq %rcx, -0x30(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x50(%rbp)
movsd -0x8(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
callq 0x1170
movl -0x50(%rbp), %edi
cvttsd2si %xmm0, %esi
callq 0x4fb0
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rbp)
movsd -0x8(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
callq 0x1050
movl -0x4c(%rbp), %edi
cvttsd2si %xmm0, %esi
callq 0x4fb0
movl %eax, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x34(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jne 0x5e6e
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jg 0x5e6c
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5e25
jmp 0x5eed
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jg 0x5eeb
movsd 0x16179(%rip), %xmm0    # 0x1c010
subsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x40(%rbp), %xmm1
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x48(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x5e75
jmp 0x5eed
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/synthesis.cpp
// Function: (anonymous namespace)::GetAperiodicRatio(double, double, int, double**, int, double*)
void GetAperiodicRatio(double current_time, double frame_period,
    int f0_length, double **aperiodicity, int fft_size,
    double *aperiodic_spectrum) {
  int current_frame_floor =
    MyMin(f0_length - 1, static_cast<int>(floor(current_time / frame_period)));
  int current_frame_ceil =
    MyMin(f0_length - 1, static_cast<int>(ceil(current_time / frame_period)));
  double interpolation = current_time / frame_period - current_frame_floor;

  if (current_frame_floor == current_frame_ceil) {
    for (int i = 0; i <= fft_size / 2; ++i)
      aperiodic_spectrum[i] =
        pow(aperiodicity[current_frame_floor][i], 2.0);
  } else {
    for (int i = 0; i <= fft_size / 2; ++i)
      aperiodic_spectrum[i] =
        pow((1.0 - interpolation) * aperiodicity[current_frame_floor][i] +
        interpolation * aperiodicity[current_frame_ceil][i], 2.0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq %rcx, -0x30(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x50(%rbp)
movsd -0x8(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
callq 0x1170
movl -0x50(%rbp), %edi
cvttsd2si %xmm0, %esi
callq 0x4fb0
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rbp)
movsd -0x8(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
callq 0x1050
movl -0x4c(%rbp), %edi
cvttsd2si %xmm0, %esi
callq 0x4fb0
movl %eax, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x34(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jne 0x5fee
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jg 0x5fe9
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1603c(%rip), %xmm1    # 0x1c008
callq 0x1180
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5f95
jmp 0x607d
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jg 0x607b
movsd 0x15ff9(%rip), %xmm0    # 0x1c010
subsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x40(%rbp), %xmm1
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x48(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x15fad(%rip), %xmm1    # 0x1c008
callq 0x1180
movq -0x30(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x5ff5
jmp 0x607d
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/synthesis.cpp
// Function: (anonymous namespace)::GetNoiseSpectrum(int, int, ForwardRealFFT*)
void GetNoiseSpectrum(int noise_size, int fft_size,
    ForwardRealFFT *forward_real_fft) {
  double average = 0.0;
  for (int i = 0; i < noise_size; ++i) {
    forward_real_fft->waveform[i] = randn();
    average += forward_real_fft->waveform[i];
  }

  average /= static_cast<double>(noise_size);
  for (int i = 0; i < noise_size; ++i)
    forward_real_fft->waveform[i] -= average;
  for (int i = noise_size; i < fft_size; ++i)
    forward_real_fft->waveform[i] = 0.0;
  fft_execute(forward_real_fft->forward_fft);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6648
callq 0x7590
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6604
cvtsi2sdl -0x4(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6694
movsd -0x18(%rbp), %xmm1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6662
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x66c1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x669a
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x70(%rbp), %rdi
movl $0x48, %edx
callq 0x10b0
movq -0x30(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups -0x40(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xd500
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: Sleepwalking[P]world-octave/matlabfunctions.cpp
// Function: histc(double*, int, double*, int, int*)
void histc(double *x, int x_length, double *edges, int edges_length,
    int *index) {
  int count = 1;

  int i = 0;
  for (; i < edges_length; ++i) {
    index[i] = 1;
    if (edges[i] >= x[0]) break;
  }
  for (; i < edges_length; ++i) {
    if (edges[i] < x[count]) {
      index[i] = count;
    } else {
      index[i--] = count++;
    }
    if (count == x_length) break;
  }
  count--;
  for (i++; i < edges_length; ++i) index[i] = count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6821
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
ucomisd (%rax), %xmm0
jb 0x6814
jmp 0x6821
jmp 0x6816
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x67e4
jmp 0x6823
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6892
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x685b
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x687b
movl -0x2c(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, -0x30(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x6885
jmp 0x6892
jmp 0x6887
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6823
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x68c5
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x68a4
popq %rbp
retq
nopw (%rax,%rax)
// File: Sleepwalking[P]world-octave/matlabfunctions.cpp
// Function: randn()
double randn(void) {
  static unsigned int x = 123456789;
  static unsigned int y = 362436069;
  static unsigned int z = 521288629;
  static unsigned int w = 88675123;
  unsigned int t;
  t = x ^ (x << 11);
  x = y;
  y = z;
  z = w;

  unsigned int tmp = 0;
  for (int i = 0; i < 12; ++i) {
    t = x ^ (x << 11);
    x = y;
    y = z;
    z = w;
    w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
    tmp += w >> 4;
  }
  return tmp / 268435456.0 - 6.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18b56(%rip), %eax     # 0x200f0
movl 0x18b50(%rip), %ecx     # 0x200f0
shll $0xb, %ecx
xorl %ecx, %eax
movl %eax, -0x4(%rbp)
movl 0x18b46(%rip), %eax     # 0x200f4
movl %eax, 0x18b3c(%rip)     # 0x200f0
movl 0x18b3e(%rip), %eax     # 0x200f8
movl %eax, 0x18b34(%rip)     # 0x200f4
movl 0x18b36(%rip), %eax     # 0x200fc
movl %eax, 0x18b2c(%rip)     # 0x200f8
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xc, -0xc(%rbp)
jge 0x7656
movl 0x18b0a(%rip), %eax     # 0x200f0
movl 0x18b04(%rip), %ecx     # 0x200f0
shll $0xb, %ecx
xorl %ecx, %eax
movl %eax, -0x4(%rbp)
movl 0x18afa(%rip), %eax     # 0x200f4
movl %eax, 0x18af0(%rip)     # 0x200f0
movl 0x18af2(%rip), %eax     # 0x200f8
movl %eax, 0x18ae8(%rip)     # 0x200f4
movl 0x18aea(%rip), %eax     # 0x200fc
movl %eax, 0x18ae0(%rip)     # 0x200f8
movl 0x18ade(%rip), %eax     # 0x200fc
movl 0x18ad8(%rip), %ecx     # 0x200fc
shrl $0x13, %ecx
xorl %ecx, %eax
movl -0x4(%rbp), %ecx
movl -0x4(%rbp), %edx
shrl $0x8, %edx
xorl %edx, %ecx
xorl %ecx, %eax
movl %eax, 0x18ac0(%rip)     # 0x200fc
movl 0x18aba(%rip), %eax     # 0x200fc
shrl $0x4, %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x75da
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x14c52(%rip), %xmm1    # 0x1c2b8
divsd %xmm1, %xmm0
movsd 0x14c3e(%rip), %xmm1    # 0x1c2b0
subsd %xmm1, %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: Sleepwalking[P]world-octave/matlabfunctions.cpp
// Function: matlab_std(double*, int)
double matlab_std(double *x, int x_length) {
  double average = 0.0;
  for (int i = 0; i < x_length; ++i) average += x[i];
  average /= x_length;

  double s = 0.0;
  for (int i = 0; i < x_length; ++i) s += pow(x[i] - average, 2.0);
  s /= (x_length - 1);

  return sqrt(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7b88
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7b5e
cvtsi2sdl -0xc(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7be6
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x18(%rbp), %xmm0
movsd 0x1443c(%rip), %xmm1    # 0x1c008
callq 0x1180
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7baa
movl -0xc(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd -0x28(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x1090
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Sleepwalking[P]world-octave/cheaptrick.cpp
// Function: (anonymous namespace)::CheapTrickGeneralBody(double*, int, int, double, int, double, ForwardRealFFT*, InverseRealFFT*, double*)
void CheapTrickGeneralBody(double *x, int x_length, int fs, double current_f0,
    int fft_size, double temporal_position, ForwardRealFFT *forward_real_fft,
    InverseRealFFT *inverse_real_fft, double *spectral_envelope) {
  // F0-adaptive windowing
  GetWindowedWaveform(x, x_length, fs, current_f0, temporal_position,
    forward_real_fft);

  // Calculate power spectrum with DC correction
  // Note: The calculated power spectrum is stored in an array for waveform.
  // In this imprementation, power spectrum is transformed by FFT (NOT IFFT).
  // However, the same result is obtained.
  // This is tricky but important for simple implementation.
  GetPowerSpectrum(fs, current_f0, fft_size, forward_real_fft);

  // Smoothing of the power (linear axis)
  // forward_real_fft.waveform is the power spectrum.
  LinearSmoothing(forward_real_fft->waveform, current_f0 * 2.0 / 3.0,
      fs, fft_size, forward_real_fft->waveform);

  // Smoothing (log axis) and spectral recovery on the cepstrum domain.
  SmoothingWithRecovery(current_f0, fs, fft_size, forward_real_fft,
      inverse_real_fft, spectral_envelope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movsd %xmm1, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq -0x30(%rbp), %rcx
callq 0x87e0
movl -0x10(%rbp), %edi
movsd -0x18(%rbp), %xmm0
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x8aa0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movsd 0x1387c(%rip), %xmm0    # 0x1c008
mulsd -0x18(%rbp), %xmm0
movsd 0x1392f(%rip), %xmm1    # 0x1c0c8
divsd %xmm1, %xmm0
movl -0x10(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x14d0
movsd -0x18(%rbp), %xmm0
movl -0x10(%rbp), %edi
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x8c30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/cheaptrick.cpp
// Function: (anonymous namespace)::GetPowerSpectrum(int, double, int, ForwardRealFFT*)
void GetPowerSpectrum(int fs, double current_f0, int fft_size,
    ForwardRealFFT *forward_real_fft) {
  int half_window_length = matlab_round(1.5 * fs / current_f0);

  // FFT
  for (int i = half_window_length * 2 + 1; i < fft_size; ++i)
    forward_real_fft->waveform[i] = 0.0;
  fft_execute(forward_real_fft->forward_fft);

  // Calculation of the power spectrum.
  double *power_spectrum = forward_real_fft->waveform;
  for (int i = 0; i <= fft_size / 2; ++i)
    power_spectrum[i] =
      forward_real_fft->spectrum[i][0] * forward_real_fft->spectrum[i][0] +
      forward_real_fft->spectrum[i][1] * forward_real_fft->spectrum[i][1];

  // DC correction
  DCCorrection(power_spectrum, current_f0, fs, fft_size, power_spectrum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x138f1(%rip), %xmm0    # 0x1c3b8
mulsd %xmm1, %xmm0
divsd -0x10(%rbp), %xmm0
callq 0x72e0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8b0a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8ae3
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
leaq -0x70(%rbp), %rdi
movl $0x48, %edx
callq 0x10b0
movq -0x30(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups -0x40(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xd500
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x80(%rbp), %eax
cmpl %ecx, %eax
jg 0x8c01
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x7c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x7c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm2
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x7c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x7c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x78(%rbp), %rax
movslq -0x7c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x8b62
movq -0x78(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movl -0x4(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x78(%rbp), %rcx
callq 0x1310
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/stonemask.cpp
// Function: (anonymous namespace)::GetMainWindow(double, int*, int, int, double, double, double*)
void GetMainWindow(double current_time, int *index_raw,
    int base_time_length, int fs, double center_location,
    double window_length_in_time, double *main_window) {
  double tmp = 0.0;
  for (int i = 0; i < base_time_length; ++i) {
    tmp = static_cast<double>(index_raw[i] - 1.0) /
      fs - current_time - center_location;
    main_window[i] = 0.42 +
      0.5 * cos(2.0 * world::kPi * tmp / window_length_in_time) +
      0.08 * cos(4.0 * world::kPi * tmp / window_length_in_time);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9c2c
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movsd 0x1247b(%rip), %xmm1    # 0x1c010
subsd %xmm1, %xmm0
cvtsi2sdl -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
subsd -0x8(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x124a7(%rip), %xmm0    # 0x1c060
mulsd -0x38(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
callq 0x11a0
movsd 0x12458(%rip), %xmm1    # 0x1c028
mulsd %xmm1, %xmm0
movsd 0x12824(%rip), %xmm1    # 0x1c400
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x1245b(%rip), %xmm0    # 0x1c048
mulsd -0x38(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
callq 0x11a0
movsd -0x48(%rbp), %xmm1
movsd 0x127ef(%rip), %xmm2    # 0x1c3f8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x9b74
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/stonemask.cpp
// Function: (anonymous namespace)::GetDiffWindow(double*, int, double*)
void GetDiffWindow(double *main_window, int base_time_length,
    double *diff_window) {
  diff_window[0] = -main_window[1] / 2.0;
  for (int i = 1; i < base_time_length - 1; ++i)
    diff_window[i] = -(main_window[i + 1] - main_window[i - 1]) / 2.0;
  diff_window[base_time_length - 1] = main_window[base_time_length - 2] / 2.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x12391(%rip), %xmm1    # 0x1c008
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x9cf6
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x1232e(%rip), %xmm1    # 0x1c008
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9c8a
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x122f8(%rip), %xmm1    # 0x1c008
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
popq %rbp
retq
nopl (%rax,%rax)