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

```asm
<transformation_D2>:
  endbr64
  push   %rbx
  mov    %rdx,%r8
  movzbl (%rsi),%eax
  mov    %rcx,%r9
  movzbl (%rcx),%edx
  movzbl (%r8),%r10d
  movzbl 0x1(%rsi),%ecx
  xor    (%rdi),%r10b
  xor    0x1(%r9),%cl
  xor    %edx,%eax
  xor    %edx,%r10d
  movzbl %cl,%r11d
  lea    (%rax,%rax,1),%edx
  shr    %cl
  xor    %edx,%r10d
  mov    %r11d,%ebx
  mov    %eax,%edx
  shr    $0x7,%al
  shl    $0x7,%ebx
  shr    %dl
  add    %r11d,%r11d
  or     %ebx,%edx
  xor    %edx,%r10d
  mov    %eax,%edx
  or     %r11d,%edx
  mov    %r10b,(%rdi)
  xor    %ecx,%edx
  xor    0x1(%r9),%dl
  xor    0x1(%rdi),%dl
  xor    0x1(%r8),%dl
  mov    %dl,0x1(%rdi)
  movzbl (%r8),%eax
  xor    0x1(%r8),%dl
  xor    %r10d,%eax
  movzbl %dl,%ebx
  lea    (%rax,%rax,1),%ecx
  xor    (%rsi),%cl
  mov    %eax,%edx
  shr    $0x7,%al
  xor    %r10d,%ecx
  mov    %ebx,%r10d
  shr    %dl
  xor    (%r9),%cl
  shl    $0x7,%r10d
  mov    %ebx,%r11d
  or     %r10d,%edx
  shr    %r11b
  xor    %ecx,%edx
  mov    %eax,%ecx
  lea    (%rbx,%rbx,1),%eax
  or     %eax,%ecx
  mov    %dl,(%rsi)
  xor    %r11d,%ecx
  xor    0x1(%rdi),%cl
  xor    0x1(%rsi),%cl
  xor    0x1(%r9),%cl
  mov    %cl,0x1(%rsi)
  movzbl (%r9),%eax
  xor    0x1(%r9),%cl
  xor    %edx,%eax
  movzbl %cl,%r10d
  xor    (%r8),%dl
  xor    (%rdi),%dl
  lea    (%rax,%rax,1),%r11d
  mov    %r10d,%ebx
  add    %r10d,%r10d
  shr    %cl
  xor    %r11d,%edx
  mov    %eax,%r11d
  shl    $0x7,%ebx
  shr    %r11b
  shr    $0x7,%al
  or     %ebx,%r11d
  or     %r10d,%eax
  xor    %r11d,%edx
  xor    %ecx,%eax
  mov    %dl,(%r8)
  xor    0x1(%rsi),%al
  xor    0x1(%r8),%al
  xor    0x1(%rdi),%al
  mov    %al,0x1(%r8)
  movzbl (%rdi),%r10d
  xor    0x1(%rdi),%al
  xor    %edx,%r10d
  movzbl %al,%edi
  shr    %al
  lea    (%r10,%r10,1),%ecx
  xor    (%rsi),%cl
  mov    %edi,%r11d
  add    %edi,%edi
  xor    %edx,%ecx
  mov    %r10d,%edx
  shl    $0x7,%r11d
  xor    (%r9),%cl
  shr    %dl
  pop    %rbx
  or     %r11d,%edx
  xor    %edx,%ecx
  mov    %r10d,%edx
  shr    $0x7,%dl
  mov    %cl,(%r9)
  or     %edi,%edx
  xor    %edx,%eax
  xor    0x1(%r8),%al
  xor    0x1(%r9),%al
  xor    0x1(%rsi),%al
  mov    %al,0x1(%r9)
  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;
  }
}
```