LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Sleepwalking[P]world-octave/d4c.cpp
// Function: (anonymous namespace)::GetStaticCentroid(double*, int, int, double, int, double, ForwardRealFFT*, double*)
void GetStaticCentroid(double *x, int x_length, int fs, double current_f0,
    int fft_size, double temporal_position, ForwardRealFFT *forward_real_fft,
    double *static_centroid) {
  double *centroid1 = new double[fft_size / 2 + 1];
  double *centroid2 = new double[fft_size / 2 + 1];

  GetCentroid(x, x_length, fs, current_f0, fft_size,
      temporal_position - 0.25 / current_f0, forward_real_fft, centroid1);
  GetCentroid(x, x_length, fs, current_f0, fft_size,
      temporal_position + 0.25 / current_f0, forward_real_fft, centroid2);

  for (int i = 0; i <= fft_size / 2; ++i)
    static_centroid[i] = centroid1[i] + centroid2[i];

  DCCorrection(static_centroid, current_f0, fs, fft_size, static_centroid);
  delete[] centroid1;
  delete[] centroid2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
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)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movsd -0x18(%rbp), %xmm0
movl -0x1c(%rbp), %ecx
movsd -0x28(%rbp), %xmm1
movsd 0x11658(%rip), %xmm2    # 0x1c3e8
divsd -0x18(%rbp), %xmm2
subsd %xmm2, %xmm1
movq -0x30(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0xb550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movsd -0x18(%rbp), %xmm0
movl -0x1c(%rbp), %ecx
movsd -0x28(%rbp), %xmm1
movsd 0x11623(%rip), %xmm2    # 0x1c3e8
divsd -0x18(%rbp), %xmm2
addsd %xmm2, %xmm1
movq -0x30(%rbp), %r8
movq -0x48(%rbp), %r9
callq 0xb550
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x50(%rbp), %eax
cmpl %ecx, %eax
jg 0xae2e
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xade2
movq -0x38(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movl -0x10(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0x1310
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xae5d
movq -0x58(%rbp), %rdi
callq 0x1110
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xae74
movq -0x60(%rbp), %rdi
callq 0x1110
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Sleepwalking[P]world-octave/d4c.cpp
// Function: (anonymous namespace)::GetStaticGroupDelay(double*, double*, int, double, int, double*)
void GetStaticGroupDelay(double *static_centroid,
    double *smoothed_power_spectrum, int fs, double current_f0,
    int fft_size, double *static_group_delay) {
  for (int i = 0; i <= fft_size / 2; ++i)
    static_group_delay[i] = static_centroid[i] / smoothed_power_spectrum[i];
  LinearSmoothing(static_group_delay, current_f0 / 2.0, fs, fft_size,
      static_group_delay);

  double *smoothed_group_delay = new double[fft_size / 2 + 1];
  LinearSmoothing(static_group_delay, current_f0, fs, fft_size,
      smoothed_group_delay);

  for (int i = 0; i <= fft_size / 2; ++i)
    static_group_delay[i] -= smoothed_group_delay[i];

  delete[] smoothed_group_delay;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jg 0xb0d2
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
divsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xb086
movq -0x30(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd 0x10f25(%rip), %xmm1    # 0x1c008
divsd %xmm1, %xmm0
movl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0x14d0
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x40(%rbp), %rcx
callq 0x14d0
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jg 0xb192
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xb14a
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xb1a9
movq -0x58(%rbp), %rdi
callq 0x1110
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: fft_plan_dft_1d(int, double (*) [2], double (*) [2], int, unsigned int)
fft_plan fft_plan_dft_1d(int n, fft_complex *in, fft_complex *out, int sign,
    unsigned int flags) {
  void makewt(int nw, int *ip, double *w);

  fft_plan output = {0};
  output.n = n;
  output.in = NULL;
  output.c_in = in;
  output.out = NULL;
  output.c_out = out;
  output.sign = sign;
  output.flags = flags;
  output.input = new double[n * 2];
  output.ip = new int[n];
  output.w = new double[n * 5 / 4];

  output.ip[0] = 0;
  makewt(output.n >> 1, output.ip, output.w);
  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
xorl %esi, %esi
movl $0x48, %edx
callq 0x1080
movq -0x30(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, (%rdi)
movq $0x0, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
movq $0x0, 0x28(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x4(%rdi)
movl -0x20(%rbp), %eax
movl %eax, 0x8(%rdi)
movl -0x4(%rbp), %eax
shll %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
movq %rax, 0x30(%rdi)
movslq -0x4(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
movq %rax, 0x38(%rdi)
imull $0x5, -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cltq
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 -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x38(%rax), %rcx
movl $0x0, (%rcx)
movl (%rax), %edi
sarl %edi
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
callq 0xcd00
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: fft_plan_dft_c2r_1d(int, double (*) [2], double*, unsigned int)
fft_plan fft_plan_dft_c2r_1d(int n, fft_complex *in, double *out,
    unsigned int flags) {
  void makewt(int nw, int *ip, double *w);
  void makect(int nc, int *ip, double *c);

  fft_plan output = {0};
  output.n = n;
  output.in = NULL;
  output.c_in = in;
  output.out = out;
  output.c_out = NULL;
  output.sign = FFT_BACKWARD;
  output.flags = flags;
  output.input = new double[n];
  output.ip = new int[n];
  output.w = new double[n * 5 / 4];

  output.ip[0] = 0;
  makewt(output.n >> 2, output.ip, output.w);
  makect(output.n >> 2, output.ip, output.w + (output.n >> 2));
  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
xorl %esi, %esi
movl $0x48, %edx
callq 0x1080
movq -0x30(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, (%rdi)
movq $0x0, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x28(%rdi)
movq $0x0, 0x20(%rdi)
movl $0x2, 0x4(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x8(%rdi)
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 -0x30(%rbp), %rdi
movq %rax, 0x30(%rdi)
movslq -0x4(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
movq %rax, 0x38(%rdi)
imull $0x5, -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cltq
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 -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x38(%rax), %rcx
movl $0x0, (%rcx)
movl (%rax), %edi
sarl $0x2, %edi
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
callq 0xcd00
movq -0x30(%rbp), %rax
movl (%rax), %edi
sarl $0x2, %edi
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
movl (%rax), %eax
sarl $0x2, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0xd2a0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: makect(int, int*, double*)
void makect(int nc, int *ip, double *c) {
  int j, nch;
  double delta;

  ip[1] = nc;
  if (nc > 1) {
    nch = nc >> 1;
    delta = atan(1.0) / nch;
    c[0] = cos(delta * nch);
    c[nch] = 0.5 * c[0];
    for (j = 1; j < nch; j++) {
      c[j] = 0.5 * cos(delta * j);
      c[nc - j] = 0.5 * sin(delta * j);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
cmpl $0x1, -0x4(%rbp)
jle 0xd3a1
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x20(%rbp)
movsd 0xed39(%rip), %xmm0     # 0x1c010
callq 0x10c0
cvtsi2sdl -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x11a0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0xed17(%rip), %xmm0     # 0x1c028
mulsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xd39f
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x11a0
movaps %xmm0, %xmm1
movsd 0xecd9(%rip), %xmm0     # 0x1c028
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x1060
movaps %xmm0, %xmm1
movsd 0xecaa(%rip), %xmm0     # 0x1c028
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
subl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd329
jmp 0xd3a1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: fft_plan_dft_r2c_1d(int, double*, double (*) [2], unsigned int)
fft_plan fft_plan_dft_r2c_1d(int n, double *in, fft_complex *out,
    unsigned int flags) {
  void makewt(int nw, int *ip, double *w);
  void makect(int nc, int *ip, double *c);

  fft_plan output = {0};
  output.n = n;
  output.in = in;
  output.c_in = NULL;
  output.out = NULL;
  output.c_out = out;
  output.sign = FFT_FORWARD;
  output.flags = flags;
  output.input = new double[n];
  output.ip = new int[n];
  output.w = new double[n * 5 / 4];

  output.ip[0] = 0;
  makewt(output.n >> 2, output.ip, output.w);
  makect(output.n >> 2, output.ip, output.w + (output.n >> 2));
  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
xorl %esi, %esi
movl $0x48, %edx
callq 0x1080
movq -0x30(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x28(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rdi)
movl $0x1, 0x4(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x8(%rdi)
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 -0x30(%rbp), %rdi
movq %rax, 0x30(%rdi)
movslq -0x4(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
movq %rax, 0x38(%rdi)
imull $0x5, -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cltq
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 -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x38(%rax), %rcx
movl $0x0, (%rcx)
movl (%rax), %edi
sarl $0x2, %edi
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
callq 0xcd00
movq -0x30(%rbp), %rax
movl (%rax), %edi
sarl $0x2, %edi
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
movl (%rax), %eax
sarl $0x2, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0xd2a0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: fft_execute(fft_plan)
void fft_execute(fft_plan p) {
  if (p.sign == FFT_FORWARD) {
    ForwardFFT(p);
  } else {  // ifft
    BackwardFFT(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpl $0x1, 0x4(%rax)
jne 0xd562
movq -0x98(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movl $0x48, %edx
callq 0x10b0
movq -0x8(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movups -0x18(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xd5c0
jmp 0xd5ac
movq -0x98(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x48, %edx
callq 0x10b0
movq -0x50(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0x90(%rbp), %xmm0
movups -0x80(%rbp), %xmm1
movups -0x70(%rbp), %xmm2
movups -0x60(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xd830
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: fft_destroy_plan(fft_plan)
void fft_destroy_plan(fft_plan p) {
  p.n = 0;
  p.in = NULL;
  p.c_in = NULL;
  p.out = NULL;
  p.c_out = NULL;
  p.sign = 0;
  p.flags = 0;
  delete[] p.input;
  delete[] p.ip;
  delete[] p.w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, (%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x20(%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0xdacb
movq -0x8(%rbp), %rdi
callq 0x1110
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xdae6
movq -0x18(%rbp), %rdi
callq 0x1110
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xdb01
movq -0x20(%rbp), %rdi
callq 0x1110
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: cdft(int, int, double*, int*, double*)
void cdft(int n, int isgn, double *a, int *ip, double *w) {
  void cftfsub(int n, double *a, int *ip, int nw, double *w);
  void cftbsub(int n, double *a, int *ip, int nw, double *w);
  int nw;

  nw = ip[0];
  if (isgn >= 0) {
    cftfsub(n, a, ip, nw, w);
  } else {
    cftbsub(n, a, ip, nw, w);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0xdb52
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0xdb70
jmp 0xdb69
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0xdca0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: cftfsub(int, double*, int*, int, double*)
void cftfsub(int n, double *a, int *ip, int nw, double *w) {
  void bitrv2(int n, int *ip, double *a);
  void bitrv216(double *a);
  void bitrv208(double *a);
  void cftf1st(int n, double *a, double *w);
  void cftrec4(int n, double *a, int nw, double *w);
  void cftleaf(int n, int isplt, double *a, int nw, double *w);
  void cftfx41(int n, double *a, int nw, double *w);
  void cftf161(double *a, double *w);
  void cftf081(double *a, double *w);
  void cftf040(double *a);
  void cftx020(double *a);

  if (n > 8) {
    if (n > 32) {
      cftf1st(n, a, &w[nw - (n >> 2)]);
    if (n > 512) {
      cftrec4(n, a, nw, w);
    } else if (n > 128) {
      cftleaf(n, 1, a, nw, w);
    } else {
      cftfx41(n, a, nw, w);
    }
      bitrv2(n, ip, a);
    } else if (n == 32) {
      cftf161(a, &w[nw - 8]);
      bitrv216(a);
    } else {
      cftf081(a, w);
      bitrv208(a);
    }
  } else if (n == 8) {
    cftf040(a);
  } else if (n == 4) {
    cftx020(a);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x8, -0x4(%rbp)
jle 0xdc71
cmpl $0x20, -0x4(%rbp)
jle 0xdc2a
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl -0x4(%rbp), %ecx
sarl $0x2, %ecx
subl %ecx, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0xe360
cmpl $0x200, -0x4(%rbp)      # imm = 0x200
jle 0xdbe0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0xfe30
jmp 0xdc18
cmpl $0x80, -0x4(%rbp)
jle 0xdc03
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movl $0x1, %esi
callq 0xff30
jmp 0xdc16
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x10590
jmp 0xdc18
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x106d0
jmp 0xdc6f
cmpl $0x20, -0x4(%rbp)
jne 0xdc57
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x11f40
movq -0x10(%rbp), %rdi
callq 0x12c40
jmp 0xdc6d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12f70
movq -0x10(%rbp), %rdi
callq 0x133f0
jmp 0xdc6f
jmp 0xdc95
cmpl $0x8, -0x4(%rbp)
jne 0xdc82
movq -0x10(%rbp), %rdi
callq 0x134e0
jmp 0xdc93
cmpl $0x4, -0x4(%rbp)
jne 0xdc91
movq -0x10(%rbp), %rdi
callq 0x13640
jmp 0xdc93
jmp 0xdc95
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: cftbsub(int, double*, int*, int, double*)
void cftbsub(int n, double *a, int *ip, int nw, double *w) {
  void bitrv2conj(int n, int *ip, double *a);
  void bitrv216neg(double *a);
  void bitrv208neg(double *a);
  void cftb1st(int n, double *a, double *w);
  void cftrec4(int n, double *a, int nw, double *w);
  void cftleaf(int n, int isplt, double *a, int nw, double *w);
  void cftfx41(int n, double *a, int nw, double *w);
  void cftf161(double *a, double *w);
  void cftf081(double *a, double *w);
  void cftb040(double *a);
  void cftx020(double *a);

  if (n > 8) {
    if (n > 32) {
      cftb1st(n, a, &w[nw - (n >> 2)]);
      if (n > 512) {
        cftrec4(n, a, nw, w);
      } else if (n > 128) {
        cftleaf(n, 1, a, nw, w);
      } else {
        cftfx41(n, a, nw, w);
      }
      bitrv2conj(n, ip, a);
    } else if (n == 32) {
      cftf161(a, &w[nw - 8]);
      bitrv216neg(a);
    } else {
      cftf081(a, w);
      bitrv208neg(a);
    }
  } else if (n == 8) {
    cftb040(a);
  } else if (n == 4) {
    cftx020(a);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x8, -0x4(%rbp)
jle 0xdda1
cmpl $0x20, -0x4(%rbp)
jle 0xdd5a
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl -0x4(%rbp), %ecx
sarl $0x2, %ecx
subl %ecx, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x136c0
cmpl $0x200, -0x4(%rbp)      # imm = 0x200
jle 0xdd10
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0xfe30
jmp 0xdd48
cmpl $0x80, -0x4(%rbp)
jle 0xdd33
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movl $0x1, %esi
callq 0xff30
jmp 0xdd46
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x10590
jmp 0xdd48
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x15300
jmp 0xdd9f
cmpl $0x20, -0x4(%rbp)
jne 0xdd87
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x11f40
movq -0x10(%rbp), %rdi
callq 0x17300
jmp 0xdd9d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12f70
movq -0x10(%rbp), %rdi
callq 0x17720
jmp 0xdd9f
jmp 0xddc5
cmpl $0x8, -0x4(%rbp)
jne 0xddb2
movq -0x10(%rbp), %rdi
callq 0x178c0
jmp 0xddc3
cmpl $0x4, -0x4(%rbp)
jne 0xddc1
movq -0x10(%rbp), %rdi
callq 0x13640
jmp 0xddc3
jmp 0xddc5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: rdft(int, int, double*, int*, double*)
void rdft(int n, int isgn, double *a, int *ip, double *w) {
  void cftfsub(int n, double *a, int *ip, int nw, double *w);
  void cftbsub(int n, double *a, int *ip, int nw, double *w);
  void rftfsub(int n, double *a, int nc, double *c);
  void rftbsub(int n, double *a, int nc, double *c);
  double xi;

  int nw = ip[0];
  int nc = ip[1];

  if (isgn >= 0) {
    if (n > 4) {
      cftfsub(n, a, ip, nw, w);
      rftfsub(n, a, nc, w + nw);
    } else if (n == 4) {
      cftfsub(n, a, ip, nw, w);
    }
    xi = a[0] - a[1];
    a[0] += a[1];
    a[1] = xi;
  } else {
    a[1] = 0.5 * (a[0] - a[1]);
    a[0] -= a[1];
    if (n > 4) {
      rftbsub(n, a, nc, w + nw);
      cftbsub(n, a, ip, nw, w);
    } else if (n == 4) {
      cftbsub(n, a, ip, nw, w);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0xdea1
cmpl $0x4, -0x4(%rbp)
jle 0xde44
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0xdb70
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x30(%rbp), %edx
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
callq 0xdf50
jmp 0xde63
cmpl $0x4, -0x4(%rbp)
jne 0xde61
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0xdb70
jmp 0xde63
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0xdf3e
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
subsd 0x8(%rax), %xmm1
movsd 0xe16e(%rip), %xmm0     # 0x1c028
mulsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
cmpl $0x4, -0x4(%rbp)
jle 0xdf1d
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x30(%rbp), %edx
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
callq 0xe100
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0xdca0
jmp 0xdf3c
cmpl $0x4, -0x4(%rbp)
jne 0xdf3a
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0xdca0
jmp 0xdf3c
jmp 0xdf3e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: rftfsub(int, double*, int, double*)
void rftfsub(int n, double *a, int nc, double *c) {
  int j, k, kk, ks, m;
  double wkr, wki, xr, xi, yr, yi;

  m = n >> 1;
  ks = 2 * nc / m;
  kk = 0;
  for (j = 2; j < m; j += 2) {
    k = n - j;
    kk += ks;
    wkr = 0.5 - c[nc - kk];
    wki = c[kk];
    xr = a[j] - a[k];
    xi = a[j + 1] + a[k + 1];
    yr = wkr * xr - wki * xi;
    yi = wkr * xi + wki * xr;
    a[j] -= yr;
    a[j + 1] -= yi;
    a[k] += yr;
    a[k + 1] -= yi;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
shll %eax
cltd
idivl -0x34(%rbp)
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x2, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xe0f4
movl -0x4(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movsd 0xe071(%rip), %xmm0     # 0x1c028
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
movsd -0x48(%rbp), %xmm1
mulsd -0x58(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x58(%rbp), %xmm2
movsd -0x48(%rbp), %xmm1
mulsd -0x50(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x60(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd -0x68(%rbp), %xmm1
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd -0x60(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd -0x68(%rbp), %xmm1
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0xdf84
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: makeipt(int, int*)
void makeipt(int nw, int *ip) {
  int j, l, m, m2, p, q;

  ip[2] = 0;
  ip[3] = 16;
  m = 2;
  for (l = nw; l > 32; l >>= 2) {
    m2 = m << 1;
    q = m2 << 3;
    for (j = m; j < m2; j++) {
      p = ip[j] << 2;
      ip[m + j] = p;
      ip[m2 + j] = p + q;
    }
    m = m2;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x10, 0xc(%rax)
movl $0x2, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jle 0xe359
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xe348
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shll $0x2, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %edx
addl -0x28(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe2fb
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0xe2de
popq %rbp
retq
nopl (%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: cftrec4(int, double*, int, double*)
void cftrec4(int n, double *a, int nw, double *w) {
  int cfttree(int n, int j, int k, double *a, int nw, double *w);
  void cftleaf(int n, int isplt, double *a, int nw, double *w);
  void cftmdl1(int n, double *a, double *w);
  int isplt, j, k, m;

  m = n;
  while (m > 512) {
    m >>= 2;
    cftmdl1(m, &a[n - m], &w[nw - (m >> 1)]);
  }
  cftleaf(m, 1, &a[n - m], nw, w);
  k = 0;
  for (j = n - m; j > 0; j -= m) {
    k++;
    isplt = cfttree(m, j, k, a, nw, w);
    cftleaf(m, isplt, &a[j - m], nw, w);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x200, -0x30(%rbp)     # imm = 0x200
jle 0xfe92
movl -0x30(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x4(%rbp), %eax
subl -0x30(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %eax
movl -0x30(%rbp), %ecx
sarl %ecx
subl %ecx, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x17a20
jmp 0xfe4c
movl -0x30(%rbp), %edi
movq -0x10(%rbp), %rdx
movl -0x4(%rbp), %eax
subl -0x30(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movl $0x1, %esi
callq 0xff30
movl $0x0, -0x2c(%rbp)
movl -0x4(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0xff27
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %edi
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
movq -0x20(%rbp), %r9
callq 0x18560
movl %eax, -0x24(%rbp)
movl -0x30(%rbp), %edi
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %eax
subl -0x30(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0xff30
movl -0x30(%rbp), %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x28(%rbp)
jmp 0xfec9
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: cftfx41(int, double*, int, double*)
void cftfx41(int n, double *a, int nw, double *w) {
  void cftf161(double *a, double *w);
  void cftf162(double *a, double *w);
  void cftf081(double *a, double *w);
  void cftf082(double *a, double *w);

  if (n == 128) {
    cftf161(a, &w[nw - 8]);
    cftf162(&a[32], &w[nw - 32]);
    cftf161(&a[64], &w[nw - 8]);
    cftf161(&a[96], &w[nw - 8]);
  } else {
    cftf081(a, &w[nw - 8]);
    cftf082(&a[16], &w[nw - 8]);
    cftf081(&a[32], &w[nw - 8]);
    cftf081(&a[48], &w[nw - 8]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x80, -0x4(%rbp)
jne 0x1063d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x11f40
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x20, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x196f0
movq -0x10(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x11f40
movq -0x10(%rbp), %rdi
addq $0x300, %rdi            # imm = 0x300
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x11f40
jmp 0x106c2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x12f70
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1a780
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x12f70
movq -0x10(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x8, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x12f70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: bitrv208(double*)
void bitrv208(double *a) {
  double x1r, x1i, x3r, x3i, x4r, x4i, x6r, x6i;

  x1r = a[2];
  x1i = a[3];
  x3r = a[6];
  x3i = a[7];
  x4r = a[8];
  x4i = a[9];
  x6r = a[12];
  x6i = a[13];
  a[2] = x4r;
  a[3] = x4i;
  a[6] = x6r;
  a[7] = x6i;
  a[8] = x1r;
  a[9] = x1i;
  a[12] = x3r;
  a[13] = x3i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd 0x60(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movsd 0x68(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movsd -0x48(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x48(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x60(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x68(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: cftf040(double*)
void cftf040(double *a) {
  double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;

  x0r = a[0] + a[4];
  x0i = a[1] + a[5];
  x1r = a[0] - a[4];
  x1i = a[1] - a[5];
  x2r = a[2] + a[6];
  x2i = a[3] + a[7];
  x3r = a[2] - a[6];
  x3i = a[3] - a[7];
  a[0] = x0r + x2r;
  a[1] = x0i + x2i;
  a[2] = x1r - x3i;
  a[3] = x1i + x3r;
  a[4] = x0r - x2r;
  a[5] = x0i - x2i;
  a[6] = x1r + x3i;
  a[7] = x1i - x3r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x20(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x28(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x28(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x30(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x38(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x30(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x38(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
subsd -0x48(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x18(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movsd -0x20(%rbp), %xmm0
addsd -0x48(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movsd -0x28(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x38(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: cftx020(double*)
void cftx020(double *a) {
  double x0r, x0i;

  x0r = a[0] - a[2];
  x0i = a[1] - a[3];
  a[0] += a[2];
  a[1] += a[3];
  a[2] = x0r;
  a[3] = x0i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x18(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nop
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: bitrv208neg(double*)
void bitrv208neg(double *a) {
  double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i,
    x5r, x5i, x6r, x6i, x7r, x7i;

  x1r = a[2];
  x1i = a[3];
  x2r = a[4];
  x2i = a[5];
  x3r = a[6];
  x3i = a[7];
  x4r = a[8];
  x4i = a[9];
  x5r = a[10];
  x5i = a[11];
  x6r = a[12];
  x6i = a[13];
  x7r = a[14];
  x7i = a[15];
  a[2] = x7r;
  a[3] = x7i;
  a[4] = x3r;
  a[5] = x3i;
  a[6] = x5r;
  a[7] = x5i;
  a[8] = x1r;
  a[9] = x1i;
  a[10] = x6r;
  a[11] = x6i;
  a[12] = x2r;
  a[13] = x2i;
  a[14] = x4r;
  a[15] = x4i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movsd 0x50(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rax
movsd 0x58(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x8(%rbp), %rax
movsd 0x60(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x8(%rbp), %rax
movsd 0x68(%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x8(%rbp), %rax
movsd 0x70(%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x8(%rbp), %rax
movsd 0x78(%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x70(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x78(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movsd -0x50(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movsd -0x58(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x48(%rax)
movsd -0x60(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x50(%rax)
movsd -0x68(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x60(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x68(%rax)
movsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x70(%rax)
movsd -0x48(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x78(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: cfttree(int, int, int, double*, int, double*)
int cfttree(int n, int j, int k, double *a, int nw, double *w) {
  void cftmdl1(int n, double *a, double *w);
  void cftmdl2(int n, double *a, double *w);
  int i, isplt, m;

  if ((k & 3) != 0) {
    isplt = k & 1;
    if (isplt != 0) {
      cftmdl1(n, &a[j - n], &w[nw - (n >> 1)]);
    } else {
      cftmdl2(n, &a[j - n], &w[nw - n]);
    }
  } else {
    m = n;
    for (i = k; (i & 3) == 0; i >>= 2) {
      m <<= 2;
    }
    isplt = i & 1;
    if (isplt != 0) {
      while (m > 128) {
        cftmdl1(m, &a[j - m], &w[nw - (m >> 1)]);
        m >>= 2;
      }
    } else {
      while (m > 128) {
        cftmdl2(m, &a[j - m], &w[nw - m]);
        m >>= 2;
      }
    }
  }
  return isplt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x185fe
movl -0xc(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x185cb
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl -0x4(%rbp), %ecx
sarl %ecx
subl %ecx, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x17a20
jmp 0x185f9
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
subl -0x4(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x186e0
jmp 0x186ca
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x18629
movl -0x34(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1860a
movl -0x2c(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x18682
jmp 0x1863a
cmpl $0x80, -0x34(%rbp)
jle 0x18680
movl -0x34(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x8(%rbp), %eax
subl -0x34(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl -0x34(%rbp), %ecx
sarl %ecx
subl %ecx, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x17a20
movl -0x34(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x34(%rbp)
jmp 0x1863a
jmp 0x186c8
jmp 0x18684
cmpl $0x80, -0x34(%rbp)
jle 0x186c6
movl -0x34(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x8(%rbp), %eax
subl -0x34(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
subl -0x34(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x186e0
movl -0x34(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x34(%rbp)
jmp 0x18684
jmp 0x186c8
jmp 0x186ca
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/fft.cpp
// Function: dctsub(int, double*, int, double*)
void dctsub(int n, double *a, int nc, double *c) {
  int j, k, kk, ks, m;
  double wkr, wki, xr;

  m = n >> 1;
  ks = nc / n;
  kk = 0;
  for (j = 1; j < m; j++) {
    k = n - j;
    kk += ks;
    wkr = c[kk] - c[nc - kk];
    wki = c[kk] + c[nc - kk];
    xr = wki * a[j] - wkr * a[k];
    a[j] = wkr * a[j] + wki * a[k];
    a[k] = xr;
  }
  a[m] *= c[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl -0x4(%rbp)
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x1aea9
movl -0x4(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x40(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x48(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x50(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1ada2
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sleepwalking[P]world-octave/test.cpp
// Function: timeGetTime()
DWORD timeGetTime() {
  struct timeval tv;
  gettimeofday(&tv, NULL);
  DWORD ret = static_cast<DWORD>(tv.tv_usec / 1000 + tv.tv_sec * 1000);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1150
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
imulq $0x3e8, -0x10(%rbp), %rcx # imm = 0x3E8
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Sleepwalking[P]world-octave/test.cpp
// Function: (anonymous namespace)::CheckLoadedFile(double*, int, int, int)
bool CheckLoadedFile(double *x, int fs, int nbit, int x_length) {
  if (x == NULL) {
    printf("error: File not found.\n");
    return false;
  }

  printf("File information\n");
  printf("Sampling : %d Hz %d Bit\n", fs, nbit);
  printf("Length %d [sample]\n", x_length);
  printf("Length %f [sec]\n", static_cast<double>(x_length) / fs);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b500
leaq 0xf54(%rip), %rdi       # 0x1c447
movb $0x0, %al
callq 0x1040
movb $0x0, -0x1(%rbp)
jmp 0x1b553
leaq 0xf63(%rip), %rdi       # 0x1c46a
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0xf61(%rip), %rdi       # 0x1c47c
movb $0x0, %al
callq 0x1040
movl -0x1c(%rbp), %esi
leaq 0xf69(%rip), %rdi       # 0x1c495
movb $0x0, %al
callq 0x1040
cvtsi2sdl -0x1c(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
leaq 0xf61(%rip), %rdi       # 0x1c4a9
movb $0x1, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop