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

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