user: 请显示与下面列出的汇编代码相匹配的C语言实现：

```asm
<JGcfft>:
  endbr64
  push   %r14
  push   %r13
  mov    %rdi,%r13
  push   %r12
  push   %rbp
  lea    (%rsi,%rsi,1),%ebp
  push   %rbx
  mov    %ebp,%esi
  mov    %edx,%ebx
  sub    $0x10,%rsp
  call   <bitreverse@plt>
  cmp    $0x2,%ebp
  jle    L66
  mov    $0x2,%r12d
  xchg   %ax,%ax
L61:
  mov    %r12d,%r14d
  add    %r12d,%r12d
  test   %ebx,%ebx
  je     L65
  pxor   %xmm0,%xmm0
  cvtsi2sd %r14d,%xmm0
L69:
  movsd  D45(%rip),%xmm2
  divsd  %xmm0,%xmm2
  movss  D12(%rip),%xmm0
  cvtsd2ss %xmm2,%xmm2
  mulss  %xmm2,%xmm0
  movss  %xmm2,0x8(%rsp)
  call   <sin@plt>
  mov    D24(%rip),%rax
  movq   %rax,%xmm1
  call   <pow@plt>
  movss  0x8(%rsp),%xmm2
  pxor   %xmm5,%xmm5
  mulsd  D18(%rip),%xmm0
  cvtsd2ss %xmm0,%xmm5
  movaps %xmm2,%xmm0
  movss  %xmm5,0xc(%rsp)
  call   <sin@plt>
  movaps %xmm0,%xmm6
  test   %r14d,%r14d
  jle    L101
  lea    0x1(%r14),%r9d
  movslq %r12d,%rsi
  movss  0xc(%rsp),%xmm5
  mov    %r13,%r8
  movslq %r9d,%r9
  shl    $0x2,%rsi
  xor    %edi,%edi
  pxor   %xmm4,%xmm4
  movss  D41(%rip),%xmm3
  shl    $0x2,%r9
  nopl   0x0(%rax,%rax,1)
L106:
  lea    (%r9,%r8,1),%rdx
  mov    %r8,%rax
  mov    %edi,%ecx
  cmp    %edi,%ebp
  jle    L49
  nopl   (%rax)
L59:
  movss  -0x4(%rdx),%xmm2
  movss  (%rdx),%xmm0
  add    %r12d,%ecx
  movaps %xmm2,%xmm1
  movaps %xmm0,%xmm7
  mulss  %xmm3,%xmm1
  mulss  %xmm4,%xmm7
  mulss  %xmm4,%xmm2
  mulss  %xmm3,%xmm0
  subss  %xmm7,%xmm1
  addss  %xmm2,%xmm0
  movss  (%rax),%xmm2
  subss  %xmm1,%xmm2
  movss  %xmm2,-0x4(%rdx)
  movss  0x4(%rax),%xmm2
  subss  %xmm0,%xmm2
  movss  %xmm2,(%rdx)
  addss  (%rax),%xmm1
  addss  0x4(%rax),%xmm0
  add    %rsi,%rdx
  movss  %xmm1,(%rax)
  movss  %xmm0,0x4(%rax)
  add    %rsi,%rax
  cmp    %ecx,%ebp
  jg     L59
L49:
  movaps %xmm5,%xmm0
  movaps %xmm6,%xmm1
  add    $0x2,%edi
  add    $0x8,%r8
  mulss  %xmm4,%xmm1
  mulss  %xmm3,%xmm0
  subss  %xmm1,%xmm0
  movaps %xmm5,%xmm1
  mulss  %xmm4,%xmm1
  addss  %xmm3,%xmm0
  mulss  %xmm6,%xmm3
  addss  %xmm1,%xmm3
  addss  %xmm3,%xmm4
  cmp    %r14d,%edi
  jge    L101
  movaps %xmm0,%xmm3
  jmp    L106
  nopl   (%rax)
L101:
  cmp    %r12d,%ebp
  jg     L61
L66:
  movss  D54(%rip),%xmm1
  test   %ebx,%ebx
  je     L43
  pxor   %xmm0,%xmm0
  movsd  D39(%rip),%xmm1
  cvtsi2sd %ebp,%xmm0
  divsd  %xmm0,%xmm1
  cvtsd2ss %xmm1,%xmm1
L43:
  movslq %ebp,%rbp
  lea    0x0(%r13,%rbp,4),%rax
  cmp    %rax,%r13
  jae    L55
  nopw   0x0(%rax,%rax,1)
L97:
  movss  0x0(%r13),%xmm0
  add    $0x4,%r13
  mulss  %xmm1,%xmm0
  movss  %xmm0,-0x4(%r13)
  cmp    %r13,%rax
  ja     L97
L55:
  add    $0x10,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
L65:
  mov    %r14d,%eax
  pxor   %xmm0,%xmm0
  neg    %eax
  cvtsi2sd %eax,%xmm0
  jmp    L69
```

tool_calls: name: read_data
arguments: data_label: D45
type_infered: byte[8]
name: read_data
arguments: data_label: D12
type_infered: f32
name: read_data
arguments: data_label: D24
type_infered: f64
name: read_data
arguments: data_label: D18
type_infered: f32[2]
name: read_data
arguments: data_label: D41
type_infered: f32
name: read_data
arguments: data_label: D54
type_infered: byte[4]
name: read_data
arguments: data_label: D39
type_infered: f32[2]

tool: {"D45": [0x18,0x2d,0x44,0x54,0xfb,0x21,0x19,0x40]}

tool: D12: 0.5

tool: D24: 2

tool: {"D18": [0.0,-2.0]}

tool: D41: 1

tool: {"D54": [0x00,0x00,0x00,0x40]}

tool: {"D39": [0.0,1.875]}

assistant: ```c
void JGcfft(float x[], int NC, int forward) {
  float wr, wi, wpr, wpi, theta, scale;
  int mmax, ND, m, i, j, delta;
  ND = NC << 1;
  bitreverse(x, ND);
  for (mmax = 2; mmax < ND; mmax = delta) {
    delta = mmax << 1;
    theta = (2.0 * 3.14159265358979323846264338327) / (forward ? mmax : -mmax);
    wpr = -2.0 * pow(sin(0.5 * theta), 2.0);
    wpi = sin(theta);
    wr = 1.0;
    wi = 0.0;
    for (m = 0; m < mmax; m += 2) {
      float rtemp, itemp;
      for (i = m; i < ND; i += delta) {
        j = i + mmax;
        rtemp = wr * x[j] - wi * x[j + 1];
        itemp = wr * x[j + 1] + wi * x[j];
        x[j] = x[i] - rtemp;
        x[j + 1] = x[i + 1] - itemp;
        x[i] += rtemp;
        x[i + 1] += itemp;
      }
      rtemp = wr;
      wr = wr * wpr - wi * wpi + wr;
      wi = wi * wpr + rtemp * wpi + wi;
    }
  }
  scale = forward ? 1.0 / ND : 2.0;
  {
    float *xi = x, *xe = x + ND;
    while (xi < xe)
      *xi++ *= scale;
  }
}
```