user: 请将这段汇编代码片段转换成等效的C代码：

```asm
<transformation_D2>:
  endbr64
  push   %rbp
  push   %rbx
  mov    %rdi,%r8
  mov    %rsi,%rdi
  mov    %rdx,%rsi
  mov    %rcx,%rdx
  movzbl (%rcx),%ebx
  mov    %ebx,%eax
  xor    (%rdi),%al
  movzbl 0x1(%rdi),%r9d
  xor    0x1(%rcx),%r9b
  movzbl %r9b,%r10d
  lea    (%rax,%rax,1),%ecx
  xor    (%r8),%cl
  mov    %eax,%r11d
  shr    %r11b
  mov    %r10d,%ebp
  shl    $0x7,%ebp
  or     %ebp,%r11d
  xor    %r11d,%ecx
  xor    (%rsi),%cl
  xor    %ebx,%ecx
  mov    %cl,(%r8)
  shr    $0x7,%al
  add    %r10d,%r10d
  or     %r10d,%eax
  shr    %r9b
  xor    %r9d,%eax
  xor    0x1(%r8),%al
  xor    0x1(%rsi),%al
  xor    0x1(%rdx),%al
  mov    %al,0x1(%r8)
  mov    %ecx,%eax
  xor    (%rsi),%al
  movzbl 0x1(%rsi),%r10d
  xor    0x1(%r8),%r10b
  movzbl %r10b,%r11d
  mov    %eax,%r9d
  shr    %r9b
  mov    %r11d,%ebx
  shl    $0x7,%ebx
  or     %ebx,%r9d
  lea    (%rax,%rax,1),%ebx
  xor    %ebx,%ecx
  xor    %ecx,%r9d
  xor    (%rdi),%r9b
  xor    (%rdx),%r9b
  mov    %r9b,(%rdi)
  shr    $0x7,%al
  lea    (%r11,%r11,1),%ecx
  or     %ecx,%eax
  shr    %r10b
  xor    %r10d,%eax
  xor    0x1(%rdi),%al
  xor    0x1(%rdx),%al
  xor    0x1(%r8),%al
  mov    %al,0x1(%rdi)
  mov    %r9d,%eax
  xor    (%rdx),%al
  movzbl 0x1(%rdx),%r10d
  xor    0x1(%rdi),%r10b
  movzbl %r10b,%r11d
  lea    (%rax,%rax,1),%ecx
  xor    (%r8),%cl
  mov    %eax,%ebx
  shr    %bl
  mov    %r11d,%ebp
  shl    $0x7,%ebp
  or     %ebp,%ebx
  xor    %ebx,%ecx
  xor    (%rsi),%cl
  xor    %r9d,%ecx
  mov    %cl,(%rsi)
  shr    $0x7,%al
  lea    (%r11,%r11,1),%r9d
  or     %r9d,%eax
  shr    %r10b
  xor    %r10d,%eax
  xor    0x1(%rsi),%al
  xor    0x1(%r8),%al
  xor    0x1(%rdi),%al
  mov    %al,0x1(%rsi)
  mov    %ecx,%eax
  xor    (%r8),%al
  movzbl 0x1(%r8),%r9d
  xor    0x1(%rsi),%r9b
  movzbl %r9b,%r10d
  mov    %eax,%r8d
  shr    %r8b
  mov    %r10d,%r11d
  shl    $0x7,%r11d
  or     %r11d,%r8d
  xor    %r8d,%ecx
  lea    (%rax,%rax,1),%r8d
  xor    %r8d,%ecx
  xor    (%rdi),%cl
  xor    %cl,(%rdx)
  shr    $0x7,%al
  add    %r10d,%r10d
  or     %r10d,%eax
  shr    %r9b
  xor    %r9d,%eax
  xor    0x1(%rdx),%al
  xor    0x1(%rdi),%al
  xor    0x1(%rsi),%al
  mov    %al,0x1(%rdx)
  pop    %rbx
  pop    %rbp
  ret
```

assistant: ```c
void transformation_D2(unsigned char *x0, unsigned char *x1, unsigned char *x2, unsigned char *x3) {
  const int LEN = 16;
  unsigned char temp[LEN / 8];
  int i;
  unsigned char extL = 0, extR = 0, L = 0;
  for (i = 0; i < LEN / 8; i++)
    temp[i] = x1[i] ^ x3[i];
  for (i = 0; i < LEN / 8; i++) {
    extL = i == 0 ? temp[i] << 1 : (temp[i] << 1) | (temp[i - 1] >> 7);
    extR = i == LEN / 8 - 1 ? temp[i] >> 1 : (temp[i] >> 1) | (temp[i + 1] << 7);
    L = extL ^ extR;
    x0[i] = x0[i] ^ x2[i] ^ x3[i] ^ L;
  }
  for (i = 0; i < LEN / 8; i++)
    temp[i] = x2[i] ^ x0[i];
  for (i = 0; i < LEN / 8; i++) {
    extL = i == 0 ? temp[i] << 1 : (temp[i] << 1) | (temp[i - 1] >> 7);
    extR = i == LEN / 8 - 1 ? temp[i] >> 1 : (temp[i] >> 1) | (temp[i + 1] << 7);
    L = extL ^ extR;
    x1[i] = x1[i] ^ x3[i] ^ x0[i] ^ L;
  }
  for (i = 0; i < LEN / 8; i++)
    temp[i] = x3[i] ^ x1[i];
  for (i = 0; i < LEN / 8; i++) {
    extL = i == 0 ? temp[i] << 1 : (temp[i] << 1) | (temp[i - 1] >> 7);
    extR = i == LEN / 8 - 1 ? temp[i] >> 1 : (temp[i] >> 1) | (temp[i + 1] << 7);
    L = extL ^ extR;
    x2[i] = x2[i] ^ x0[i] ^ x1[i] ^ L;
  }
  for (i = 0; i < LEN / 8; i++)
    temp[i] = x0[i] ^ x2[i];
  for (i = 0; i < LEN / 8; i++) {
    extL = i == 0 ? temp[i] << 1 : (temp[i] << 1) | (temp[i - 1] >> 7);
    extR = i == LEN / 8 - 1 ? temp[i] >> 1 : (temp[i] >> 1) | (temp[i + 1] << 7);
    L = extL ^ extR;
    x3[i] = x3[i] ^ x1[i] ^ x2[i] ^ L;
  }
}
```