user: 请将这段汇编代码片段转换成等效的C代码：

```asm
<dftixb>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  mov    %ecx,%r13d
  push   %r12
  mov    %rsi,%r12
  push   %rbp
  mov    %rdi,%rbp
  push   %rbx
  sub    $0x28,%rsp
  mov    %r8,(%rsp)
  mov    %r9,0x8(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x18(%rsp)
  xor    %eax,%eax
  cmp    %edx,%ecx
  jg     L233
L340:
  lea    0x0(,%r13,8),%edx
  xor    %esi,%esi
  mov    %rbp,%rdi
  movslq %r13d,%rbx
  call   <memset@plt>
  lea    0x0(%r13,%r13,1),%r10d
  lea    -0x1(%r10),%eax
  test   %r13d,%r13d
  jle    L58
  lea    0x0(,%rbx,8),%rdx
  cmp    $0x1,%r13d
  lea    0x0(,%rbx,4),%rcx
  mov    %r13d,%r14d
  lea    -0x8(%rdx),%rsi
  lea    -0x4(%r12,%rdx,1),%rdi
  setne  %r15b
  mov    %rdx,%r8
  lea    0x0(%rbp,%rsi,1),%r9
  sub    %rcx,%r8
  sub    %r9,%rdi
  add    $0x8,%rdi
  cmp    $0x8,%rdi
  seta   %dil
  cmp    %r8,%rcx
  setle  %r9b
  test   %rdx,%rdx
  setle  %r11b
  or     %r11d,%r9d
  lea    0x0(%rbp,%rcx,1),%r11
  and    %r9d,%edi
  lea    (%r12,%r8,1),%r9
  and    %r15d,%edi
  cmp    %r9,%r11
  lea    (%r12,%rdx,1),%r11
  setbe  %r9b
  cmp    %r11,%rbp
  setae  %r11b
  or     %r11d,%r9d
  test   %r9b,%dil
  je     L98
  add    %r12,%rcx
  add    %rbp,%r8
  lea    0x0(%rbp,%rdx,1),%rdi
  cmp    %r8,%rcx
  setbe  %cl
  cmp    %rdi,%r12
  setae  %dil
  or     %dil,%cl
  je     L98
  lea    -0x1(%r13),%ecx
  cmp    $0x2,%ecx
  jbe    L85
  mov    %r13d,%r8d
  sub    $0x10,%rdx
  movaps D35(%rip),%xmm1
  xor    %edi,%edi
  shr    $0x2,%r8d
  lea    0x0(%rbp,%rdx,1),%r9
  xor    %ecx,%ecx
  add    %r12,%rdx
  shl    $0x4,%r8
  nop
L87:
  movups 0x0(%rbp,%rcx,1),%xmm0
  shufps $0x1b,%xmm0,%xmm0
  movups %xmm0,(%r9,%rdi,1)
  movups (%r12,%rcx,1),%xmm0
  add    $0x10,%rcx
  xorps  %xmm1,%xmm0
  shufps $0x1b,%xmm0,%xmm0
  movups %xmm0,(%rdx,%rdi,1)
  sub    $0x10,%rdi
  cmp    %r8,%rcx
  jne    L87
  mov    %r13d,%edx
  and    $0xfffffffc,%edx
  mov    %edx,%ecx
  cmp    %edx,%r13d
  je     L316
L304:
  mov    %r13d,%edi
  sub    %edx,%edi
  cmp    $0x1,%edi
  je     L102
  movq   0x0(%rbp,%rdx,4),%xmm0
  lea    0x0(,%rdx,4),%r8
  movq   D35(%rip),%xmm6
  sub    %r8,%rsi
  shufps $0xe1,%xmm0,%xmm0
  movlps %xmm0,0x0(%rbp,%rsi,1)
  movq   (%r12,%rdx,4),%xmm0
  mov    %edi,%edx
  and    $0xfffffffe,%edx
  xorps  %xmm6,%xmm0
  add    %edx,%ecx
  shufps $0xe1,%xmm0,%xmm0
  movlps %xmm0,(%r12,%rsi,1)
  cmp    %edx,%edi
  je     L316
L102:
  movslq %ecx,%rdx
  sub    %ecx,%eax
  movss  0x0(%rbp,%rdx,4),%xmm0
  cltq
  movss  %xmm0,0x0(%rbp,%rax,4)
  movss  (%r12,%rdx,4),%xmm0
  xorps  D18(%rip),%xmm0
  movss  %xmm0,(%r12,%rax,4)
L316:
  lea    0x14(%rsp),%rdx
  mov    %r10d,0x14(%rsp)
  xor    %r8d,%r8d
  xor    %r9d,%r9d
  push   0x8(%rsp)
  mov    $0x1,%ecx
  mov    %r12,%rsi
  mov    %rbp,%rdi
  push   0x8(%rsp)
  call   <fourt@plt>
  lea    0x4(,%rbx,4),%rcx
  lea    0x0(,%rbx,4),%rsi
  pop    %rdi
  lea    0xc(%r12,%rcx,1),%rax
  lea    0x10(%rbp),%rdi
  pop    %r8
  cmp    %rax,%rbp
  lea    (%r12,%rsi,1),%rdx
  lea    0x4(%rbp),%r8
  setae  %al
  cmp    %rdi,%rdx
  setae  %dil
  or     %edi,%eax
  mov    %r12,%rdi
  sub    %r8,%rdi
  cmp    $0x8,%rdi
  seta   %dil
  and    %r15d,%edi
  and    %edi,%eax
  mov    %rcx,%rdi
  neg    %rdi
  cmp    $0x8,%rdi
  seta   %dil
  test   %dil,%al
  je     L118
  add    %rbp,%rcx
  mov    %r12,%rax
  sub    %rcx,%rax
  cmp    $0x8,%rax
  jbe    L118
  lea    -0x1(%r13),%eax
  cmp    $0x2,%eax
  jbe    L186
  mov    %r13d,%ecx
  add    %rbp,%rsi
  xor    %eax,%eax
  shr    $0x2,%ecx
  shl    $0x4,%rcx
  nopl   0x0(%rax,%rax,1)
L333:
  movups (%rsi,%rax,1),%xmm4
  movups %xmm4,0x0(%rbp,%rax,1)
  movups (%rdx,%rax,1),%xmm5
  movups %xmm5,(%r12,%rax,1)
  add    $0x10,%rax
  cmp    %rcx,%rax
  jne    L333
  mov    %r13d,%edx
  and    $0xfffffffc,%edx
  mov    %edx,%eax
  cmp    %r13d,%edx
  je     L162
L203:
  mov    %r13d,%ecx
  sub    %edx,%ecx
  cmp    $0x1,%ecx
  je     L306
  lea    (%rbx,%rdx,1),%rsi
  mov    0x0(%rbp,%rsi,4),%rdi
  mov    %rdi,0x0(%rbp,%rdx,4)
  mov    (%r12,%rsi,4),%rsi
  mov    %rsi,(%r12,%rdx,4)
  mov    %ecx,%edx
  and    $0xfffffffe,%edx
  add    %edx,%eax
  cmp    %edx,%ecx
  je     L162
L306:
  lea    0x0(%r13,%rax,1),%edx
  cltq
  movslq %edx,%rdx
  movss  0x0(%rbp,%rdx,4),%xmm0
  movss  %xmm0,0x0(%rbp,%rax,4)
  movss  (%r12,%rdx,4),%xmm0
  movss  %xmm0,(%r12,%rax,4)
L162:
  pxor   %xmm1,%xmm1
  movsd  D5(%rip),%xmm0
  lea    0xf(%r12),%rax
  cvtsi2sd %r13d,%xmm1
  sub    %rbp,%rax
  divsd  %xmm1,%xmm0
  cvtsd2ss %xmm0,%xmm0
  cmp    $0x1e,%rax
  jbe    L45
  test   %r15b,%r15b
  je     L45
  lea    -0x1(%r13),%eax
  cmp    $0x2,%eax
  jbe    L97
  mov    %r13d,%edx
  movaps %xmm0,%xmm2
  xor    %eax,%eax
  shr    $0x2,%edx
  shufps $0x0,%xmm2,%xmm2
  shl    $0x4,%rdx
  nopl   0x0(%rax)
L318:
  movups 0x0(%rbp,%rax,1),%xmm1
  mulps  %xmm2,%xmm1
  movups %xmm1,0x0(%rbp,%rax,1)
  movups (%r12,%rax,1),%xmm1
  mulps  %xmm2,%xmm1
  movups %xmm1,(%r12,%rax,1)
  add    $0x10,%rax
  cmp    %rdx,%rax
  jne    L318
  mov    %r13d,%edx
  and    $0xfffffffc,%edx
  mov    %edx,%eax
  cmp    %r13d,%edx
  je     L11
  mov    %r13d,%r14d
  sub    %edx,%r14d
  cmp    $0x1,%r14d
  je     L76
L35:
  shl    $0x2,%rdx
  movaps %xmm0,%xmm1
  lea    0x0(%rbp,%rdx,1),%rcx
  shufps $0xe0,%xmm1,%xmm1
  add    %r12,%rdx
  movq   (%rcx),%xmm2
  mulps  %xmm1,%xmm2
  movlps %xmm2,(%rcx)
  movq   (%rdx),%xmm2
  mulps  %xmm1,%xmm2
  movlps %xmm2,(%rdx)
  mov    %r14d,%edx
  and    $0xfffffffe,%edx
  add    %edx,%eax
  cmp    %r14d,%edx
  je     L11
L76:
  cltq
  shl    $0x2,%rax
  add    %rax,%rbp
  add    %r12,%rax
  movss  0x0(%rbp),%xmm1
  mulss  %xmm0,%xmm1
  movss  %xmm1,0x0(%rbp)
  mulss  (%rax),%xmm0
  movss  %xmm0,(%rax)
L11:
  mov    0x18(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L154
  add    $0x28,%rsp
  mov    %r13d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax,%rax,1)
L233:
  mov    %ecx,%r8d
  sub    %edx,%r8d
  movslq %edx,%rdx
  shl    $0x2,%r8d
  lea    (%rsi,%rdx,4),%rdi
  xor    %esi,%esi
  mov    %r8d,%edx
  call   <memset@plt>
  jmp    L340
L98:
  cltq
  xor    %edx,%edx
  movss  D18(%rip),%xmm1
  shl    $0x2,%rax
L264:
  movss  0x0(%rbp,%rdx,4),%xmm0
  movss  %xmm0,0x0(%rbp,%rax,1)
  movss  (%r12,%rdx,4),%xmm0
  add    $0x1,%rdx
  xorps  %xmm1,%xmm0
  movss  %xmm0,(%r12,%rax,1)
  sub    $0x4,%rax
  cmp    %rbx,%rdx
  jne    L264
  jmp    L316
  nopl   (%rax)
L118:
  add    %rbp,%rsi
  xor    %eax,%eax
  nopl   (%rax)
L181:
  movss  (%rsi,%rax,4),%xmm0
  movss  %xmm0,0x0(%rbp,%rax,4)
  movss  (%rdx,%rax,4),%xmm0
  movss  %xmm0,(%r12,%rax,4)
  add    $0x1,%rax
  cmp    %rbx,%rax
  jne    L181
  jmp    L162
  nopl   0x0(%rax)
L45:
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L215:
  movss  0x0(%rbp,%rax,4),%xmm1
  mulss  %xmm0,%xmm1
  movss  %xmm1,0x0(%rbp,%rax,4)
  movss  (%r12,%rax,4),%xmm1
  mulss  %xmm0,%xmm1
  movss  %xmm1,(%r12,%rax,4)
  add    $0x1,%rax
  cmp    %rax,%rbx
  jne    L215
  jmp    L11
  cs nopw 0x0(%rax,%rax,1)
L58:
  mov    %r10d,0x14(%rsp)
  lea    0x14(%rsp),%rdx
  xor    %r9d,%r9d
  xor    %r8d,%r8d
  push   0x8(%rsp)
  mov    $0x1,%ecx
  mov    %r12,%rsi
  mov    %rbp,%rdi
  push   0x8(%rsp)
  call   <fourt@plt>
  pop    %rax
  pop    %rdx
  jmp    L11
L85:
  xor    %edx,%edx
  xor    %ecx,%ecx
  jmp    L304
L97:
  xor    %edx,%edx
  xor    %eax,%eax
  jmp    L35
L186:
  xor    %edx,%edx
  xor    %eax,%eax
  jmp    L203
L154:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: label: D35
type_infered: byte[16]
name: extract_symbolic_data
arguments: label: D18
type_infered: byte[16]
name: extract_symbolic_data
arguments: label: D5
type_infered: f64

tool: {"D35": [0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x80]}

tool: {"D18": [0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]}

tool: D5: 1

assistant: ```c
int dftixb(float *xrr, float *xri, int isize, int ntot, float *workr, float *worki) {
  int i, ntotp1;
  float scale;
  if (ntot > isize)
    memset(xri + isize, 0, sizeof(float) * (ntot - isize));
  memset(xrr, 0, sizeof(float) * ntot * 2);
  ntotp1 = 2 * ntot - 1;
  for (i = 0; i < ntot; i++) {
    xrr[ntotp1 - i] = xrr[i];
    xri[ntotp1 - i] = -xri[i];
  }
  ntotp1 = ntot * 2;
  fourt(xrr, xri, &ntotp1, 1, 0, 0, workr, worki);
  for (i = 0; i < ntot; i++) {
    xrr[i] = xrr[i + ntot];
    xri[i] = xri[i + ntot];
  }
  scale = 1.0 / ntot;
  for (i = 0; i < ntot; i++) {
    xrr[i] *= scale;
    xri[i] *= scale;
  }
  return ntot;
}
```