user: 提供的汇编代码用C语言表示会是什么样子:

```asm
<pdu_decode>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  mov    %esi,%ebp
  mov    %r9,0x8(%rsp)
  mov    0x78(%rsp),%r15
  mov    0x80(%rsp),%rsi
  mov    %fs:0x28,%rax
  mov    %rax,0x28(%rsp)
  xor    %eax,%eax
  test   %ebp,%ebp
  jle    L153
  mov    %rdi,%rbx
  mov    %rdx,%r14
  movzbl (%rdi),%r12d
  lea    0x1(%r12),%eax
  cmp    %eax,%ebp
  jle    L60
  cltq
  movzbl (%rdi,%rax,1),%edx
  shr    $0x4,%dl
  movzbl %dl,%edx
  mov    %edx,(%rsi)
  lea    0x1(%rdi,%rax,1),%r13
  movzbl 0x0(%r13),%esi
  cmp    %r8d,%esi
  jge    L46
  lea    0x3(%rdi,%rax,1),%rdi
  mov    %rcx,%rdx
  call   <DecodePhoneNumber@plt>
  movzbl 0x0(%r13),%eax
  add    $0x1,%eax
  sar    %eax
  lea    0x4(%r12,%rax,1),%r13d
  movslq %r13d,%r12
  movzbl 0x2(%rbx,%r12,1),%edi
  call   <SwapDecimalNibble@plt>
  add    $0x64,%eax
  mov    %eax,0x10(%rsp)
  movzbl 0x3(%rbx,%r12,1),%edi
  call   <SwapDecimalNibble@plt>
  sub    $0x1,%eax
  mov    %eax,0x14(%rsp)
  movzbl 0x4(%rbx,%r12,1),%edi
  call   <SwapDecimalNibble@plt>
  mov    %eax,0x18(%rsp)
  movzbl 0x5(%rbx,%r12,1),%edi
  call   <SwapDecimalNibble@plt>
  mov    %eax,0x1c(%rsp)
  movzbl 0x6(%rbx,%r12,1),%edi
  call   <SwapDecimalNibble@plt>
  mov    %eax,0x20(%rsp)
  movzbl 0x7(%rbx,%r12,1),%edi
  call   <SwapDecimalNibble@plt>
  mov    %eax,0x24(%rsp)
  movzbl 0x8(%rbx,%r12,1),%edi
  call   <SwapDecimalNibble@plt>
  mov    %eax,%r12d
  lea    0x10(%rsp),%rdi
  call   <mktime@plt>
  movsbl %r12b,%r12d
  imul   $0x384,%r12d,%r12d
  movslq %r12d,%r12
  sub    %r12,%rax
  mov    %rax,(%r14)
  lea    0x9(%r13),%eax
  cmp    %eax,%ebp
  jle    L137
  cltq
  movzbl (%rbx,%rax,1),%r14d
  movzbl %r14b,%r12d
  cmp    0x70(%rsp),%r12d
  jg     L117
  lea    0x1(%r13),%edx
  movslq %edx,%rdx
  movzbl (%rbx,%rdx,1),%edx
  movzbl %dl,%ecx
  mov    %ecx,(%r15)
  test   %dl,%dl
  je     L82
  cmp    $0x8,%dl
  je     L121
L77:
  cmp    0x70(%rsp),%r12d
  jge    L147
  movzbl %r14b,%r14d
  mov    0x8(%rsp),%rax
  movb   $0x0,(%rax,%r14,1)
L71:
  mov    0x28(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L12
  mov    %r12d,%eax
  add    $0x38,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L82:
  add    $0xa,%r13d
  mov    %ebp,%esi
  sub    %r13d,%esi
  lea    0x1(%rbx,%rax,1),%rdi
  mov    %r12d,%ecx
  mov    0x8(%rsp),%rdx
  call   <DecodePDUMessage_GSM_7bit@plt>
  cmp    %eax,%r12d
  je     L77
  mov    $0xffffffff,%r12d
  jmp    L71
L121:
  lea    0x1(%rbx,%rax,1),%rsi
  mov    %r12d,%edx
  mov    0x8(%rsp),%rdi
  call   <memcpy@plt>
  jmp    L77
L147:
  movslq 0x70(%rsp),%rax
  mov    0x8(%rsp),%rcx
  movb   $0x0,-0x1(%rcx,%rax,1)
  jmp    L71
L153:
  mov    $0xffffffff,%r12d
  jmp    L71
L60:
  mov    $0xfffffffe,%r12d
  jmp    L71
L46:
  mov    $0xfffffffd,%r12d
  jmp    L71
L137:
  mov    $0xffffffff,%r12d
  jmp    L71
L117:
  mov    $0xffffffff,%r12d
  jmp    L71
L12:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
int pdu_decode(const unsigned char *buffer, int buffer_length, time_t *output_sms_time, char *output_sender_phone_number, int sender_phone_number_size, char *output_sms_text, int sms_text_size, int *tp_dcs, int *user_payload_header_size) {
  if (buffer_length <= 0)
    return -1;
  const int sms_deliver_start = 1 + buffer[0];
  if (sms_deliver_start + 1 > buffer_length)
    return -2;
  const int user_data_header_length = (buffer[sms_deliver_start] >> 4);
  *user_payload_header_size = user_data_header_length;
  const int sender_number_length = buffer[sms_deliver_start + 1];
  if (sender_number_length + 1 > sender_phone_number_size)
    return -3;
  DecodePhoneNumber(buffer + sms_deliver_start + 3, sender_number_length, output_sender_phone_number);
  const int sms_pid_start = sms_deliver_start + 3 + (buffer[sms_deliver_start + 1] + 1) / 2;
  struct tm sms_broken_time;
  sms_broken_time.tm_year = 100 + SwapDecimalNibble(buffer[sms_pid_start + 2]);
  sms_broken_time.tm_mon = SwapDecimalNibble(buffer[sms_pid_start + 3]) - 1;
  sms_broken_time.tm_mday = SwapDecimalNibble(buffer[sms_pid_start + 4]);
  sms_broken_time.tm_hour = SwapDecimalNibble(buffer[sms_pid_start + 5]);
  sms_broken_time.tm_min = SwapDecimalNibble(buffer[sms_pid_start + 6]);
  sms_broken_time.tm_sec = SwapDecimalNibble(buffer[sms_pid_start + 7]);
  const char gmt_offset = SwapDecimalNibble(buffer[sms_pid_start + 8]);
  (*output_sms_time) = mktime(&sms_broken_time) - gmt_offset * 15 * 60;
  const int sms_start = sms_pid_start + 2 + 7;
  if (sms_start + 1 > buffer_length)
    return -1;
  const int output_sms_text_length = buffer[sms_start];
  if (sms_text_size < output_sms_text_length)
    return -1;
  const int sms_tp_dcs_start = sms_pid_start + 1;
  *tp_dcs = buffer[sms_tp_dcs_start];
  switch (*tp_dcs) {
  case 0: {
    int decoded_sms_text_size = DecodePDUMessage_GSM_7bit(buffer + sms_start + 1, buffer_length - (sms_start + 1), output_sms_text, output_sms_text_length);
    if (decoded_sms_text_size != output_sms_text_length)
      return -1;
    break;
  }
  case 8: {
    memcpy(output_sms_text, buffer + sms_start + 1, output_sms_text_length);
    break;
  }
  default:
    break;
  }
  if (output_sms_text_length < sms_text_size)
    output_sms_text[output_sms_text_length] = 0;
  else
    output_sms_text[sms_text_size - 1] = 0;
  return output_sms_text_length;
}
```