user: 这段汇编代码用C语言表示是什么样的？

```asm
<bn_mul_recursive>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  mov    %rdi,(%rsp)
  mov    %rsi,0x8(%rsp)
  mov    %rdx,%r14
  mov    %ecx,%ebx
  cmp    $0xf,%ecx
  jle    L118
  mov    %r8,%r12
  mov    %ecx,%ebp
  shr    $0x1f,%ebp
  add    %ecx,%ebp
  sar    %ebp
  movslq %ebp,%rax
  lea    0x0(,%rax,8),%r15
  mov    %r15,0x10(%rsp)
  mov    0x8(%rsp),%rdi
  mov    %rdi,%rax
  add    %r15,%rax
  mov    %rax,0x18(%rsp)
  mov    %ebp,%edx
  mov    %rax,%rsi
  call   <bn_cmp_words@plt>
  mov    %eax,%r13d
  lea    (%r14,%r15,1),%rax
  mov    %rax,0x20(%rsp)
  mov    %ebp,%edx
  mov    %r14,%rsi
  mov    %rax,%rdi
  call   <bn_cmp_words@plt>
  lea    0x0(%r13,%r13,2),%edx
  lea    0x4(%rdx,%rax,1),%eax
  cmp    $0x8,%eax
  ja     L50
  mov    %eax,%eax
  lea    D9(%rip),%rdx
  movslq (%rdx,%rax,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
L118:
  mov    %ecx,%r8d
  mov    %rdx,%rcx
  mov    %ebx,%edx
  call   <bn_mul_normal@plt>
L0:
  add    $0x38,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  mov    %ebp,%ecx
  mov    0x8(%rsp),%rdx
  mov    0x18(%rsp),%rsi
  mov    %r12,%rdi
  call   <bn_sub_words@plt>
  mov    0x10(%rsp),%rax
  lea    (%r12,%rax,1),%rdi
  mov    %ebp,%ecx
  mov    0x20(%rsp),%rdx
  mov    %r14,%rsi
  call   <bn_sub_words@plt>
  movl   $0x0,0x2c(%rsp)
L94:
  lea    (%rbx,%rbx,1),%eax
  cltq
  lea    (%r12,%rax,8),%r15
L8:
  mov    0x10(%rsp),%rax
  lea    (%r12,%rax,1),%rdx
  movslq %ebx,%rax
  lea    0x0(,%rax,8),%r13
  lea    (%r12,%r13,1),%rdi
  mov    %r15,%r8
  mov    %ebp,%ecx
  mov    %r12,%rsi
  call   <bn_mul_recursive>
  mov    %r15,%r8
  mov    %ebp,%ecx
  mov    %r14,%rdx
  mov    0x8(%rsp),%rsi
  mov    (%rsp),%rdi
  call   <bn_mul_recursive>
  mov    %r13,%rax
  mov    %r13,%r14
  mov    (%rsp),%r13
  mov    %rax,0x8(%rsp)
  add    %rax,%r13
  mov    %r15,%r8
  mov    %ebp,%ecx
  mov    0x20(%rsp),%rdx
  mov    0x18(%rsp),%rsi
  mov    %r13,%rdi
  call   <bn_mul_recursive>
  mov    %ebx,%ecx
  mov    %r13,%rdx
  mov    (%rsp),%rsi
  mov    %r12,%rdi
  call   <bn_add_words@plt>
  mov    %rax,%r13
  mov    %eax,%r15d
  cmpl   $0x0,0x2c(%rsp)
  je     L77
  mov    0x8(%rsp),%rdi
  add    %r12,%rdi
  mov    %ebx,%ecx
  mov    %rdi,%rdx
  mov    %r12,%rsi
  call   <bn_sub_words@plt>
  sub    %eax,%r13d
L80:
  mov    0x10(%rsp),%rdi
  mov    (%rsp),%r15
  add    %r15,%rdi
  lea    (%r12,%r14,1),%rdx
  mov    %ebx,%ecx
  mov    %rdi,%rsi
  call   <bn_add_words@plt>
  add    %eax,%r13d
  je     L0
  add    %ebx,%ebp
  movslq %ebp,%rbp
  lea    (%r15,%rbp,8),%rax
  movslq %r13d,%rdx
  add    (%rax),%r13d
  mov    %r13,(%rax)
  cmp    %r13,%rdx
  jbe    L0
L2:
  add    $0x8,%rax
  mov    (%rax),%rdx
  lea    0x1(%rdx),%edx
  mov    %rdx,(%rax)
  test   %rdx,%rdx
  je     L2
  jmp    L0
  mov    %ebp,%ecx
  mov    0x8(%rsp),%rdx
  mov    0x18(%rsp),%rsi
  mov    %r12,%rdi
  call   <bn_sub_words@plt>
  mov    0x10(%rsp),%rax
  lea    (%r12,%rax,1),%rdi
  mov    %ebp,%ecx
  mov    %r14,%rdx
  mov    0x20(%rsp),%rsi
  call   <bn_sub_words@plt>
  movl   $0x1,0x2c(%rsp)
  jmp    L94
  mov    %ebp,%ecx
  mov    0x18(%rsp),%rdx
  mov    0x8(%rsp),%rsi
  mov    %r12,%rdi
  call   <bn_sub_words@plt>
  mov    0x10(%rsp),%rax
  lea    (%r12,%rax,1),%rdi
  mov    %ebp,%ecx
  mov    0x20(%rsp),%rdx
  mov    %r14,%rsi
  call   <bn_sub_words@plt>
  movl   $0x1,0x2c(%rsp)
  jmp    L94
  mov    %ebp,%ecx
  mov    0x18(%rsp),%rdx
  mov    0x8(%rsp),%rsi
  mov    %r12,%rdi
  call   <bn_sub_words@plt>
  mov    0x10(%rsp),%rax
  lea    (%r12,%rax,1),%rdi
  mov    %ebp,%ecx
  mov    %r14,%rdx
  mov    0x20(%rsp),%rsi
  call   <bn_sub_words@plt>
  movl   $0x0,0x2c(%rsp)
  jmp    L94
L50:
  lea    (%rbx,%rbx,1),%eax
  cltq
  lea    (%r12,%rax,8),%r15
  movl   $0x0,0x2c(%rsp)
  jmp    L8
  lea    (%rbx,%rbx,1),%eax
  cltq
  lea    (%r12,%rax,8),%r15
  movslq %ebx,%r13
  lea    0x0(,%rbx,8),%edx
  shl    $0x3,%r13
  lea    (%r12,%r13,1),%rdi
  mov    $0x0,%esi
  call   <memset@plt>
  mov    %r15,%r8
  mov    %ebp,%ecx
  mov    %r14,%rdx
  mov    0x8(%rsp),%rsi
  mov    (%rsp),%rdi
  call   <bn_mul_recursive>
  mov    %r13,%r14
  add    (%rsp),%r13
  mov    %r15,%r8
  mov    %ebp,%ecx
  mov    0x20(%rsp),%rdx
  mov    0x18(%rsp),%rsi
  mov    %r13,%rdi
  call   <bn_mul_recursive>
  mov    %ebx,%ecx
  mov    %r13,%rdx
  mov    (%rsp),%rsi
  mov    %r12,%rdi
  call   <bn_add_words@plt>
  mov    %eax,%r15d
L77:
  lea    (%r12,%r14,1),%rdi
  mov    %ebx,%ecx
  mov    %r12,%rdx
  mov    %rdi,%rsi
  call   <bn_add_words@plt>
  lea    (%r15,%rax,1),%r13d
  jmp    L80
```

assistant: ```c
void bn_mul_recursive(unsigned long *r, unsigned long *a, unsigned long *b, int n2, unsigned long *t) {
  int n = n2 / 2, c1, c2;
  unsigned int neg, zero;
  unsigned long ln, lo, *p;
  if (n2 < (16)) {
    bn_mul_normal(r, a, n2, b, n2);
    return;
  }
  c1 = bn_cmp_words(a, &(a[n]), n);
  c2 = bn_cmp_words(&(b[n]), b, n);
  zero = neg = 0;
  switch (c1 * 3 + c2) {
  case -4:
    bn_sub_words(t, &(a[n]), a, n);
    bn_sub_words(&(t[n]), b, &(b[n]), n);
    break;
  case -3:
    zero = 1;
    break;
  case -2:
    bn_sub_words(t, &(a[n]), a, n);
    bn_sub_words(&(t[n]), &(b[n]), b, n);
    neg = 1;
    break;
  case -1:
  case 0:
  case 1:
    zero = 1;
    break;
  case 2:
    bn_sub_words(t, a, &(a[n]), n);
    bn_sub_words(&(t[n]), b, &(b[n]), n);
    neg = 1;
    break;
  case 3:
    zero = 1;
    break;
  case 4:
    bn_sub_words(t, a, &(a[n]), n);
    bn_sub_words(&(t[n]), &(b[n]), b, n);
    break;
  }
  {
    p = &(t[n2 * 2]);
    if (!zero)
      bn_mul_recursive(&(t[n2]), t, &(t[n]), n, p);
    else
      memset(&(t[n2]), 0, n2 * sizeof(unsigned long));
    bn_mul_recursive(r, a, b, n, p);
    bn_mul_recursive(&(r[n2]), &(a[n]), &(b[n]), n, p);
  }
  c1 = (int)(bn_add_words(t, r, &(r[n2]), n2));
  if (neg) {
    c1 -= (int)(bn_sub_words(&(t[n2]), t, &(t[n2]), n2));
  } else {
    c1 += (int)(bn_add_words(&(t[n2]), &(t[n2]), t, n2));
  }
  c1 += (int)(bn_add_words(&(r[n]), &(r[n]), &(t[n2]), n2));
  if (c1) {
    p = &(r[n + n2]);
    lo = *p;
    ln = (lo + c1) & (0xffffffffL);
    *p = ln;
    if (ln < (unsigned long)c1) {
      do {
        p++;
        lo = *p;
        ln = (lo + 1) & (0xffffffffL);
        *p = ln;
      } while (ln == 0);
    }
  }
}
```