user: Please show me the C implementation that matches the assembly code listed below:

```asm
<xor_salsa8>:
  endbr64
  push   %r15
  mov    %rdi,%r8
  mov    %rsi,%rax
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    (%rdi),%edx
  xor    (%rsi),%edx
  mov    0x18(%rdi),%ebx
  mov    %edx,(%rdi)
  mov    %edx,%r9d
  mov    %edx,-0x38(%rsp)
  mov    0x4(%rdi),%edx
  xor    0x4(%rsi),%edx
  mov    %edx,0x4(%rdi)
  mov    %edx,%ecx
  mov    %edx,-0x34(%rsp)
  mov    0x8(%rdi),%edx
  xor    0x8(%rsi),%edx
  mov    %edx,0x8(%rdi)
  mov    %edx,%r12d
  mov    %edx,-0x30(%rsp)
  mov    0xc(%rdi),%edx
  xor    0xc(%rsi),%edx
  mov    %edx,0xc(%rdi)
  mov    %edx,%r10d
  mov    %edx,-0x2c(%rsp)
  mov    0x10(%rdi),%edx
  xor    0x10(%rsi),%edx
  mov    %edx,0x10(%rdi)
  mov    %edx,%r11d
  mov    %edx,-0x28(%rsp)
  mov    0x14(%rdi),%edx
  xor    0x14(%rsi),%edx
  mov    %edx,0x14(%rdi)
  xor    0x18(%rsi),%ebx
  mov    %edx,-0x48(%rsp)
  mov    %ebx,-0x44(%rsp)
  mov    %ebx,0x18(%rdi)
  mov    0x1c(%rdi),%edi
  xor    0x1c(%rsi),%edi
  mov    0x20(%r8),%esi
  mov    0x28(%r8),%r14d
  mov    0x2c(%r8),%r15d
  mov    %edi,0x1c(%r8)
  xor    0x20(%rax),%esi
  mov    0x30(%r8),%ebp
  mov    %edi,-0x24(%rsp)
  mov    %esi,0x20(%r8)
  mov    %esi,%ebx
  mov    0x34(%r8),%r13d
  mov    %esi,-0x20(%rsp)
  mov    0x24(%r8),%esi
  xor    0x24(%rax),%esi
  mov    %esi,0x24(%r8)
  xor    0x28(%rax),%r14d
  mov    %r14d,0x28(%r8)
  xor    0x2c(%rax),%r15d
  mov    %r15d,0x2c(%r8)
  xor    0x30(%rax),%ebp
  mov    %ebp,0x30(%r8)
  xor    0x34(%rax),%r13d
  mov    %r13d,0x34(%r8)
  mov    %r14d,-0x40(%rsp)
  mov    %ebp,%r14d
  mov    %ebp,-0x18(%rsp)
  mov    0x38(%r8),%ebp
  xor    0x38(%rax),%ebp
  mov    %esi,-0x1c(%rsp)
  mov    %r15d,-0x3c(%rsp)
  mov    %r13d,-0x14(%rsp)
  mov    %ebp,-0x10(%rsp)
  mov    %ebp,0x38(%r8)
  mov    0x3c(%r8),%edx
  xor    0x3c(%rax),%edx
  mov    -0x3c(%rsp),%eax
  mov    %r8,-0x8(%rsp)
  mov    %r14d,%r8d
  mov    %edx,-0xc(%rsp)
  mov    %edx,%r15d
  mov    -0x48(%rsp),%edx
  mov    %r12d,%r14d
  mov    %eax,-0x60(%rsp)
  mov    -0x40(%rsp),%eax
  mov    %r13d,%r12d
  mov    %r11d,%r13d
  movl   $0x4,-0x4c(%rsp)
  mov    %eax,-0x58(%rsp)
  mov    -0x44(%rsp),%eax
  mov    %edx,-0x5c(%rsp)
  mov    %ecx,%edx
  mov    %eax,-0x64(%rsp)
  mov    %esi,%eax
  mov    %edi,%esi
  mov    %ebx,%edi
  mov    %r10d,%ebx
  mov    %eax,%r10d
L3:
  mov    -0x5c(%rsp),%eax
  lea    (%r9,%r8,1),%r11d
  rol    $0x7,%r11d
  add    %edx,%eax
  xor    %r13d,%r11d
  mov    -0x5c(%rsp),%r13d
  rol    $0x7,%eax
  xor    %r10d,%eax
  mov    -0x60(%rsp),%r10d
  mov    %eax,%ecx
  mov    -0x64(%rsp),%eax
  add    -0x58(%rsp),%eax
  add    %ecx,%r13d
  add    %r15d,%r10d
  rol    $0x7,%eax
  rol    $0x9,%r13d
  xor    %ebp,%eax
  rol    $0x7,%r10d
  xor    %r12d,%r13d
  mov    -0x58(%rsp),%r12d
  xor    %ebx,%r10d
  mov    %eax,%ebp
  lea    (%r11,%r9,1),%ebx
  mov    %ecx,%eax
  mov    %ebp,%ecx
  add    %ebp,%r12d
  rol    $0x9,%ebx
  lea    (%rax,%r13,1),%ebp
  mov    %eax,-0x50(%rsp)
  rol    $0x9,%r12d
  xor    %edi,%ebx
  lea    (%r10,%r15,1),%edi
  rol    $0xd,%ebp
  xor    %r14d,%r12d
  lea    (%r11,%rbx,1),%r14d
  rol    $0x9,%edi
  xor    %edx,%ebp
  rol    $0xd,%r14d
  xor    %esi,%edi
  mov    %ecx,-0x54(%rsp)
  xor    %r8d,%r14d
  lea    (%r10,%rdi,1),%esi
  lea    (%rcx,%r12,1),%r8d
  lea    (%rbx,%r14,1),%eax
  rol    $0xd,%esi
  xor    -0x60(%rsp),%esi
  rol    $0xd,%r8d
  ror    $0xe,%eax
  lea    0x0(%r13,%rbp,1),%ecx
  xor    -0x64(%rsp),%r8d
  xor    %eax,%r9d
  lea    (%rdi,%rsi,1),%eax
  ror    $0xe,%ecx
  xor    -0x5c(%rsp),%ecx
  ror    $0xe,%eax
  lea    (%r12,%r8,1),%edx
  xor    %r15d,%eax
  lea    (%r10,%r9,1),%r15d
  ror    $0xe,%edx
  xor    -0x58(%rsp),%edx
  rol    $0x7,%r15d
  mov    %edx,-0x58(%rsp)
  mov    %r15d,%edx
  mov    -0x50(%rsp),%r15d
  xor    %ebp,%edx
  lea    (%r11,%rcx,1),%ebp
  rol    $0x7,%ebp
  xor    %r8d,%ebp
  mov    %r15d,%r8d
  mov    %ebp,-0x64(%rsp)
  mov    -0x58(%rsp),%ebp
  add    %ebp,%r8d
  rol    $0x7,%r8d
  xor    %esi,%r8d
  mov    -0x54(%rsp),%esi
  mov    %r8d,-0x60(%rsp)
  lea    (%rsi,%rax,1),%r8d
  rol    $0x7,%r8d
  xor    %r14d,%r8d
  lea    (%r9,%rdx,1),%r14d
  rol    $0x9,%r14d
  xor    %r12d,%r14d
  mov    -0x64(%rsp),%r12d
  lea    (%rcx,%r12,1),%esi
  lea    (%rax,%r8,1),%r12d
  rol    $0x9,%esi
  rol    $0x9,%r12d
  xor    %edi,%esi
  mov    %ebp,%edi
  mov    -0x60(%rsp),%ebp
  xor    %r13d,%r12d
  add    %ebp,%edi
  rol    $0x9,%edi
  xor    %ebx,%edi
  lea    (%rdx,%r14,1),%ebx
  rol    $0xd,%ebx
  xor    %r10d,%ebx
  mov    -0x64(%rsp),%r10d
  lea    (%r10,%rsi,1),%r13d
  lea    0x0(%rbp,%rdi,1),%r10d
  rol    $0xd,%r13d
  rol    $0xd,%r10d
  lea    (%r8,%r12,1),%ebp
  xor    %r11d,%r13d
  lea    (%r14,%rbx,1),%r11d
  xor    %r15d,%r10d
  rol    $0xd,%ebp
  ror    $0xe,%r11d
  xor    -0x54(%rsp),%ebp
  xor    %r11d,%r9d
  lea    (%rsi,%r13,1),%r11d
  lea    (%r12,%rbp,1),%r15d
  ror    $0xe,%r11d
  ror    $0xe,%r15d
  xor    %ecx,%r11d
  lea    (%rdi,%r10,1),%ecx
  xor    %eax,%r15d
  ror    $0xe,%ecx
  xor    -0x58(%rsp),%ecx
  subl   $0x1,-0x4c(%rsp)
  mov    %r11d,-0x5c(%rsp)
  mov    %ecx,-0x58(%rsp)
  jne    L3
  mov    %r10d,%eax
  mov    %ebx,%r10d
  mov    %edi,%ebx
  mov    %esi,%edi
  mov    %eax,%esi
  mov    -0x38(%rsp),%eax
  mov    %r13d,%r11d
  mov    %r12d,%r13d
  mov    %r14d,%r12d
  mov    %r8d,%r14d
  mov    -0x8(%rsp),%r8
  add    %r9d,%eax
  mov    %eax,(%r8)
  mov    -0x34(%rsp),%eax
  add    %edx,%eax
  mov    %eax,0x4(%r8)
  mov    -0x30(%rsp),%eax
  add    %r12d,%eax
  mov    %eax,0x8(%r8)
  mov    -0x2c(%rsp),%eax
  add    %r10d,%eax
  mov    %eax,0xc(%r8)
  mov    -0x28(%rsp),%eax
  add    %r11d,%eax
  mov    %eax,0x10(%r8)
  mov    -0x48(%rsp),%eax
  add    -0x5c(%rsp),%eax
  mov    %eax,0x14(%r8)
  mov    -0x44(%rsp),%eax
  add    -0x64(%rsp),%eax
  mov    %eax,0x18(%r8)
  mov    -0x24(%rsp),%eax
  add    %edi,%eax
  mov    %eax,0x1c(%r8)
  mov    -0x20(%rsp),%eax
  add    %ebx,%eax
  mov    %eax,0x20(%r8)
  mov    -0x1c(%rsp),%eax
  add    %esi,%eax
  mov    %eax,0x24(%r8)
  mov    -0x40(%rsp),%eax
  add    %ecx,%eax
  mov    %eax,0x28(%r8)
  mov    -0x3c(%rsp),%eax
  add    -0x60(%rsp),%eax
  mov    %eax,0x2c(%r8)
  mov    -0x18(%rsp),%eax
  add    %r14d,%eax
  mov    %eax,0x30(%r8)
  mov    -0x14(%rsp),%eax
  add    %r13d,%eax
  mov    %eax,0x34(%r8)
  mov    -0x10(%rsp),%eax
  add    %ebp,%eax
  mov    %eax,0x38(%r8)
  mov    -0xc(%rsp),%eax
  add    %r15d,%eax
  mov    %eax,0x3c(%r8)
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

assistant: ```c
void xor_salsa8(unsigned int B[16], const unsigned int Bx[16]) {
  unsigned int x00, x01, x02, x03, x04, x05, x06, x07, x08, x09, x10, x11, x12, x13, x14, x15;
  int i;
  x00 = (B[0] ^= Bx[0]);
  x01 = (B[1] ^= Bx[1]);
  x02 = (B[2] ^= Bx[2]);
  x03 = (B[3] ^= Bx[3]);
  x04 = (B[4] ^= Bx[4]);
  x05 = (B[5] ^= Bx[5]);
  x06 = (B[6] ^= Bx[6]);
  x07 = (B[7] ^= Bx[7]);
  x08 = (B[8] ^= Bx[8]);
  x09 = (B[9] ^= Bx[9]);
  x10 = (B[10] ^= Bx[10]);
  x11 = (B[11] ^= Bx[11]);
  x12 = (B[12] ^= Bx[12]);
  x13 = (B[13] ^= Bx[13]);
  x14 = (B[14] ^= Bx[14]);
  x15 = (B[15] ^= Bx[15]);
  for (i = 0; i < 8; i += 2) {
    x04 ^= (((x00 + x12) << (7)) | ((x00 + x12) >> (32 - (7))));
    x09 ^= (((x05 + x01) << (7)) | ((x05 + x01) >> (32 - (7))));
    x14 ^= (((x10 + x06) << (7)) | ((x10 + x06) >> (32 - (7))));
    x03 ^= (((x15 + x11) << (7)) | ((x15 + x11) >> (32 - (7))));
    x08 ^= (((x04 + x00) << (9)) | ((x04 + x00) >> (32 - (9))));
    x13 ^= (((x09 + x05) << (9)) | ((x09 + x05) >> (32 - (9))));
    x02 ^= (((x14 + x10) << (9)) | ((x14 + x10) >> (32 - (9))));
    x07 ^= (((x03 + x15) << (9)) | ((x03 + x15) >> (32 - (9))));
    x12 ^= (((x08 + x04) << (13)) | ((x08 + x04) >> (32 - (13))));
    x01 ^= (((x13 + x09) << (13)) | ((x13 + x09) >> (32 - (13))));
    x06 ^= (((x02 + x14) << (13)) | ((x02 + x14) >> (32 - (13))));
    x11 ^= (((x07 + x03) << (13)) | ((x07 + x03) >> (32 - (13))));
    x00 ^= (((x12 + x08) << (18)) | ((x12 + x08) >> (32 - (18))));
    x05 ^= (((x01 + x13) << (18)) | ((x01 + x13) >> (32 - (18))));
    x10 ^= (((x06 + x02) << (18)) | ((x06 + x02) >> (32 - (18))));
    x15 ^= (((x11 + x07) << (18)) | ((x11 + x07) >> (32 - (18))));
    x01 ^= (((x00 + x03) << (7)) | ((x00 + x03) >> (32 - (7))));
    x06 ^= (((x05 + x04) << (7)) | ((x05 + x04) >> (32 - (7))));
    x11 ^= (((x10 + x09) << (7)) | ((x10 + x09) >> (32 - (7))));
    x12 ^= (((x15 + x14) << (7)) | ((x15 + x14) >> (32 - (7))));
    x02 ^= (((x01 + x00) << (9)) | ((x01 + x00) >> (32 - (9))));
    x07 ^= (((x06 + x05) << (9)) | ((x06 + x05) >> (32 - (9))));
    x08 ^= (((x11 + x10) << (9)) | ((x11 + x10) >> (32 - (9))));
    x13 ^= (((x12 + x15) << (9)) | ((x12 + x15) >> (32 - (9))));
    x03 ^= (((x02 + x01) << (13)) | ((x02 + x01) >> (32 - (13))));
    x04 ^= (((x07 + x06) << (13)) | ((x07 + x06) >> (32 - (13))));
    x09 ^= (((x08 + x11) << (13)) | ((x08 + x11) >> (32 - (13))));
    x14 ^= (((x13 + x12) << (13)) | ((x13 + x12) >> (32 - (13))));
    x00 ^= (((x03 + x02) << (18)) | ((x03 + x02) >> (32 - (18))));
    x05 ^= (((x04 + x07) << (18)) | ((x04 + x07) >> (32 - (18))));
    x10 ^= (((x09 + x08) << (18)) | ((x09 + x08) >> (32 - (18))));
    x15 ^= (((x14 + x13) << (18)) | ((x14 + x13) >> (32 - (18))));
  }
  B[0] += x00;
  B[1] += x01;
  B[2] += x02;
  B[3] += x03;
  B[4] += x04;
  B[5] += x05;
  B[6] += x06;
  B[7] += x07;
  B[8] += x08;
  B[9] += x09;
  B[10] += x10;
  B[11] += x11;
  B[12] += x12;
  B[13] += x13;
  B[14] += x14;
  B[15] += x15;
}
```