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

```asm
<bansol>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rsi,%r12
  mov    %rdx,%rbp
  lea    (%rcx,%rcx,1),%r13d
  lea    0x1(%r13),%r10d
  test   %ecx,%ecx
  jne    L163
  test   %r8d,%r8d
  jle    L24
  movslq %r10d,%r10
  shl    $0x3,%r10
  mov    %r8d,%r8d
  mov    $0x0,%eax
L50:
  movsd  (%r12,%rax,8),%xmm0
  divsd  (%rdi),%xmm0
  movsd  %xmm0,0x0(%rbp,%rax,8)
  add    $0x1,%rax
  add    %r10,%rdi
  cmp    %r8,%rax
  jne    L50
L24:
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L163:
  mov    %ecx,%r9d
  lea    -0x1(%r8),%ebx
  cmp    $0x1,%ecx
  je     L173
  movsd  (%rsi),%xmm0
  movsd  %xmm0,(%rdx)
  cmp    $0x1,%r8d
  jle    L110
  lea    0x10(%rdx),%rcx
  lea    0x1(%r8),%r15d
  mov    %r10d,%r14d
  mov    $0x2,%r11d
  movslq %r9d,%rax
  mov    %rax,-0x8(%rsp)
L70:
  lea    -0x1(%r11),%eax
  cmp    %r9d,%eax
  cmovg  %r9d,%eax
  movsd  -0x8(%r12,%r11,8),%xmm1
  test   %eax,%eax
  jle    L53
  mov    %eax,%eax
  neg    %rax
  lea    0x0(,%rax,8),%rdx
  movslq %r14d,%rax
  add    -0x8(%rsp),%rax
  lea    (%rdi,%rax,8),%rsi
  mov    $0x0,%eax
L157:
  movsd  -0x8(%rsi,%rax,1),%xmm0
  mulsd  -0x10(%rcx,%rax,1),%xmm0
  subsd  %xmm0,%xmm1
  sub    $0x8,%rax
  cmp    %rdx,%rax
  jne    L157
L53:
  movsd  %xmm1,-0x8(%rcx)
  add    $0x1,%r11
  add    %r10d,%r14d
  add    $0x8,%rcx
  cmp    %r15,%r11
  jne    L70
L110:
  movslq %r8d,%rax
  lea    -0x8(%rbp,%rax,8),%rcx
  mov    %r10d,%eax
  imul   %ebx,%eax
  lea    (%rax,%r9,1),%edx
  movslq %edx,%rdx
  movsd  (%rcx),%xmm0
  divsd  (%rdi,%rdx,8),%xmm0
  movsd  %xmm0,(%rcx)
  test   %ebx,%ebx
  jle    L24
  movslq %ebx,%rdx
  lea    0x0(%rbp,%rdx,8),%rsi
  not    %r13d
  movslq %r13d,%r12
  shl    $0x3,%r12
  movslq %r9d,%r13
  sub    %r10d,%eax
  cltq
  add    %r13,%rax
  lea    (%rdi,%rax,8),%rbp
  lea    -0x2(%r8),%r11d
  imul   %r10d,%r11d
L150:
  mov    %r8d,%eax
  sub    %ebx,%eax
  cmp    %r9d,%eax
  cmovg  %r9d,%eax
  mov    %rsi,%rdx
  movsd  -0x8(%rsi),%xmm1
  test   %eax,%eax
  jle    L20
  lea    0x1(%rax),%r14d
  movslq %r11d,%rax
  add    %r13,%rax
  lea    (%rdi,%rax,8),%rcx
  mov    $0x1,%eax
L73:
  movsd  (%rcx,%rax,8),%xmm0
  mulsd  -0x8(%rdx,%rax,8),%xmm0
  subsd  %xmm0,%xmm1
  add    $0x1,%rax
  cmp    %r14,%rax
  jne    L73
L20:
  divsd  0x0(%rbp),%xmm1
  movsd  %xmm1,-0x8(%rdx)
  sub    $0x8,%rsi
  add    %r12,%rbp
  sub    %r10d,%r11d
  sub    $0x1,%ebx
  jne    L150
  jmp    L24
L173:
  movsd  (%rsi),%xmm0
  movsd  %xmm0,(%rdx)
  cmp    $0x1,%r8d
  jle    L16
  movslq %r10d,%rcx
  shl    $0x3,%rcx
  lea    (%rdi,%rcx,1),%rdx
  lea    -0x1(%r8),%esi
  mov    $0x0,%eax
L130:
  movsd  (%rdx),%xmm1
  mulsd  0x0(%rbp,%rax,8),%xmm1
  movsd  0x8(%r12,%rax,8),%xmm0
  subsd  %xmm1,%xmm0
  movsd  %xmm0,0x8(%rbp,%rax,8)
  add    $0x1,%rax
  add    %rcx,%rdx
  cmp    %rsi,%rax
  jne    L130
L16:
  movslq %r8d,%rax
  lea    -0x8(%rbp,%rax,8),%rcx
  mov    %r10d,%eax
  imul   %ebx,%eax
  lea    0x1(%rax),%edx
  movslq %edx,%rdx
  movsd  (%rcx),%xmm0
  divsd  (%rdi,%rdx,8),%xmm0
  movsd  %xmm0,(%rcx)
  test   %ebx,%ebx
  jle    L24
  not    %r13d
  movslq %r13d,%rcx
  shl    $0x3,%rcx
  sub    %r10d,%eax
  cltq
  lea    0x8(%rdi,%rax,8),%rdx
  movslq %ebx,%rbx
  lea    -0x8(%rbp,%rbx,8),%rax
  movslq %r8d,%rsi
  lea    -0x18(%rbp,%rsi,8),%rsi
  lea    -0x2(%r8),%edi
  shl    $0x3,%rdi
  sub    %rdi,%rsi
L177:
  movsd  0x8(%rdx),%xmm1
  mulsd  0x8(%rax),%xmm1
  movsd  (%rax),%xmm0
  subsd  %xmm1,%xmm0
  divsd  (%rdx),%xmm0
  movsd  %xmm0,(%rax)
  add    %rcx,%rdx
  sub    $0x8,%rax
  cmp    %rsi,%rax
  jne    L177
  jmp    L24
```

assistant: ```c
void bansol(double *e, double *y, double *c, int m, int n) {
  int i, k, nm1, mi, m2p1;
  double d;
  m2p1 = 2 * m + 1;
  nm1 = n - 1;
  if (m == 0) {
    for (i = 1; i <= n; i++) {
      c[i - 1] = y[i - 1] / e[(i - 1) * m2p1 + m];
    }
  } else {
    if (m == 1) {
      c[0] = y[0];
      for (i = 2; i <= n; i++) {
        c[i - 1] = y[i - 1] - e[(i - 1) * m2p1 - 1 + m] * c[i - 2];
      }
      c[n - 1] = c[n - 1] / e[(n - 1) * m2p1 + m];
      for (i = nm1; i >= 1; i--) {
        c[i - 1] = (c[i - 1] - e[(i - 1) * m2p1 + 1 + m] * c[i]) / e[(i - 1) * m2p1 + m];
      }
    } else {
      c[0] = y[0];
      for (i = 2; i <= n; i++) {
        mi = (m < (i - 1)) ? m : i - 1;
        d = y[i - 1];
        for (k = 1; k <= mi; k++) {
          d -= e[(i - 1) * m2p1 - k + m] * c[i - k - 1];
        }
        c[i - 1] = d;
      }
      c[n - 1] /= e[(n - 1) * m2p1 + m];
      for (i = nm1; i >= 1; i--) {
        mi = (m < (n - i)) ? m : n - i;
        d = c[i - 1];
        for (k = 1; k <= mi; k++) {
          d -= e[(i - 1) * m2p1 + k + m] * c[i + k - 1];
        }
        c[i - 1] = d / e[(i - 1) * m2p1 + m];
      }
    }
  }
}
```