user: 请从给定的汇编指令推导出C源代码：

```asm
<root2poly>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  push   %r15
  mov    %rdi,%r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbx
  sub    $0x48,%rsp
  mov    %rsi,-0x70(%rbp)
  mov    %edx,-0x64(%rbp)
  mov    %rsp,%rcx
  mov    %fs:0x28,%rax
  mov    %rax,-0x38(%rbp)
  mov    %edx,%eax
  lea    0x2(%rax,%rax,1),%ebx
  movslq %ebx,%rax
  lea    0xf(,%rax,8),%rdx
  shl    $0x3,%rax
  mov    %rdx,%rsi
  and    $0xfffffffffffff000,%rsi
  sub    %rsi,%rcx
  cmp    %rcx,%rsp
  je     L190
L76:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rcx,%rsp
  jne    L76
L190:
  and    $0xfff,%eax
  sub    %rax,%rsp
  test   %rax,%rax
  jne    L206
L150:
  lea    0x7(%rsp),%r13
  mov    %rdx,%rax
  mov    %rsp,%rcx
  and    $0xfffffffffffff000,%rdx
  mov    %r13,%r12
  sub    %rdx,%rcx
  and    $0xfffffffffffffff8,%r13
  and    $0xfffffffffffffff0,%rax
  shr    $0x3,%r12
  cmp    %rcx,%rsp
  je     L105
L111:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rcx,%rsp
  jne    L111
L105:
  and    $0xfff,%eax
  sub    %rax,%rsp
  test   %rax,%rax
  jne    L63
L154:
  lea    0x7(%rsp),%r14
  shl    $0x3,%ebx
  xor    %esi,%esi
  mov    %r13,%rdi
  mov    %r14,%rcx
  mov    %ebx,%edx
  and    $0xfffffffffffffff8,%r14
  shr    $0x3,%rcx
  mov    %rcx,-0x48(%rbp)
  call   <memset@plt>
  mov    %ebx,%edx
  xor    %esi,%esi
  mov    %r14,%rdi
  call   <memset@plt>
  movsd  D6(%rip),%xmm0
  mov    -0x48(%rbp),%rcx
  mov    -0x64(%rbp),%eax
  movsd  %xmm0,0x0(,%rcx,8)
  movsd  %xmm0,0x0(,%r12,8)
  test   %eax,%eax
  jle    L68
  movq   (%r15),%xmm1
  mov    %ebx,%edx
  mov    %r14,%rsi
  mov    %r13,%rdi
  movupd 0x10(,%r12,8),%xmm0
  cvtps2pd %xmm1,%xmm1
  subpd  %xmm1,%xmm0
  movups %xmm0,0x10(,%rcx,8)
  call   <memcpy@plt>
  movslq -0x64(%rbp),%rax
  cmp    $0x1,%eax
  je     L192
  mov    %rax,-0x48(%rbp)
  lea    0x20(%r13),%rax
  mov    $0x1,%r12d
  mov    %rax,-0x58(%rbp)
  lea    0x10(%r13),%rax
  mov    %rax,-0x50(%rbp)
  lea    0x20(%r14),%rax
  mov    %rax,-0x60(%rbp)
  xchg   %ax,%ax
L3:
  test   %r12d,%r12d
  mov    $0x1,%ecx
  mov    -0x58(%rbp),%rdi
  mov    -0x50(%rbp),%rsi
  movupd 0x10(%r13),%xmm0
  movq   (%r15,%r12,8),%xmm2
  cmovg  %r12d,%ecx
  mov    -0x60(%rbp),%rdx
  movapd %xmm0,%xmm1
  cvtps2pd %xmm2,%xmm2
  lea    -0x1(%rcx),%eax
  movapd %xmm2,%xmm4
  subpd  %xmm2,%xmm1
  unpcklpd %xmm2,%xmm4
  unpckhpd %xmm2,%xmm2
  movups %xmm1,0x10(%r14)
  cmp    $0x1,%eax
  jbe    L119
  lea    -0x3(%rcx),%r9d
  lea    0x30(%r13),%r8
  xor    %r10d,%r10d
  and    $0xfffffffe,%r9d
  lea    0x2(%r9),%eax
L203:
  movapd %xmm0,%xmm3
  movupd -0x10(%r8),%xmm1
  mov    %r10d,%r11d
  mov    %r8,%rsi
  mulpd  %xmm4,%xmm3
  lea    0x10(%r8),%rdi
  add    $0x20,%rdx
  add    $0x2,%r10d
  mulpd  %xmm2,%xmm0
  add    $0x20,%r8
  movapd %xmm3,%xmm5
  shufpd $0x1,%xmm0,%xmm0
  subpd  %xmm0,%xmm5
  addpd  %xmm0,%xmm3
  movapd %xmm1,%xmm0
  movsd  %xmm5,%xmm3
  subpd  %xmm3,%xmm0
  movapd %xmm1,%xmm3
  mulpd  %xmm4,%xmm3
  mulpd  %xmm2,%xmm1
  movups %xmm0,-0x20(%rdx)
  movupd -0x20(%r8),%xmm0
  movapd %xmm3,%xmm5
  shufpd $0x1,%xmm1,%xmm1
  subpd  %xmm1,%xmm5
  addpd  %xmm1,%xmm3
  movapd %xmm0,%xmm1
  movsd  %xmm5,%xmm3
  subpd  %xmm3,%xmm1
  movups %xmm1,-0x10(%rdx)
  cmp    %r11d,%r9d
  jne    L203
L129:
  xor    %r8d,%r8d
  nopw   0x0(%rax,%rax,1)
L108:
  movupd (%rsi,%r8,1),%xmm1
  movupd (%rsi,%r8,1),%xmm0
  add    $0x1,%eax
  mulpd  %xmm4,%xmm1
  mulpd  %xmm2,%xmm0
  movapd %xmm1,%xmm3
  shufpd $0x1,%xmm0,%xmm0
  subpd  %xmm0,%xmm3
  addpd  %xmm0,%xmm1
  movupd (%rdi,%r8,1),%xmm0
  movsd  %xmm3,%xmm1
  subpd  %xmm1,%xmm0
  movups %xmm0,(%rdx,%r8,1)
  add    $0x10,%r8
  cmp    %eax,%ecx
  ja     L108
  mov    %ebx,%edx
  mov    %r14,%rsi
  mov    %r13,%rdi
  add    $0x1,%r12
  call   <memcpy@plt>
  cmp    -0x48(%rbp),%r12
  jne    L3
  mov    -0x64(%rbp),%edx
  mov    -0x70(%rbp),%rcx
  xor    %eax,%eax
  shr    %edx
  shl    $0x4,%rdx
  nopl   (%rax)
L87:
  movupd 0x0(%r13,%rax,2),%xmm0
  movhpd 0x10(%r13,%rax,2),%xmm0
  movups %xmm0,(%rcx,%rax,1)
  add    $0x10,%rax
  cmp    %rax,%rdx
  jne    L87
  mov    -0x64(%rbp),%ebx
  mov    %ebx,%edx
  and    $0xfffffffe,%edx
  lea    (%rdx,%rdx,1),%eax
  movslq %edx,%rcx
  add    $0x1,%edx
  movslq %eax,%rdi
  lea    0x0(,%rcx,8),%rsi
  movsd  0x0(%r13,%rdi,8),%xmm0
  mov    -0x70(%rbp),%rdi
  movsd  %xmm0,(%rdi,%rcx,8)
  cmp    %edx,%ebx
  jl     L2
L198:
  add    $0x2,%eax
  cltq
  movsd  0x0(%r13,%rax,8),%xmm0
  mov    -0x70(%rbp),%rax
  movsd  %xmm0,0x8(%rax,%rsi,1)
L2:
  mov    -0x38(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L89
  lea    -0x28(%rbp),%rsp
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  ret
L206:
  orq    $0x0,-0x8(%rsp,%rax,1)
  jmp    L150
  nopw   0x0(%rax,%rax,1)
L119:
  xor    %eax,%eax
  jmp    L129
L68:
  jne    L2
  mov    -0x70(%rbp),%rax
  movsd  %xmm0,(%rax)
  jmp    L2
  nopl   0x0(%rax,%rax,1)
L192:
  movsd  0x0(,%r12,8),%xmm0
  mov    -0x70(%rbp),%rax
  xor    %esi,%esi
  movsd  %xmm0,(%rax)
  xor    %eax,%eax
  jmp    L198
L63:
  orq    $0x0,-0x8(%rsp,%rax,1)
  jmp    L154
L89:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: label: D6
datatype: byte[8]

tool: {"D6": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

assistant: ```c
void root2poly(float *r, double *p, const int n) {
  int i, ir, ii, j, jr, ji;
  double pp[(n + 1) * 2];
  double qq[(n + 1) * 2];
  memset(pp, 0, ((n + 1) * 2) * sizeof(double));
  memset(qq, 0, ((n + 1) * 2) * sizeof(double));
  pp[0] = qq[0] = 1;
  for (i = 0; i < n; i++) {
    ir = i * 2;
    ii = i * 2 + 1;
    qq[2] = pp[2] - r[ir];
    qq[3] = pp[3] - r[ii];
    for (j = 0; j < i; j++) {
      jr = j * 2;
      ji = j * 2 + 1;
      qq[jr + 4] = pp[jr + 4] - (pp[jr + 2] * r[ir] - pp[ji + 2] * r[ii]);
      qq[ji + 4] = pp[ji + 4] - (pp[ji + 2] * r[ir] + pp[jr + 2] * r[ii]);
    }
    memcpy(pp, qq, ((n + 1) * 2) * sizeof(double));
  }
  for (i = 0; i < (n + 1); i++) {
    p[i] = pp[i * 2];
  }
}
```