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

```asm
<InvMixColumn>:
  endbr64
  push   %rbp
  mov    %rdi,%r8
  push   %rbx
  movzbl 0x1(%rdi),%ecx
  movzbl (%rdi),%r11d
  movzbl 0x2(%rdi),%r10d
  mov    %ecx,%edx
  movzbl 0x3(%rdi),%r9d
  xor    %r11d,%edx
  mov    %r11d,%ebp
  add    %r11d,%r11d
  mov    %r10d,%eax
  mov    %r11d,%esi
  mov    %r9d,%ebx
  xor    $0x1b,%esi
  test   %bpl,%bpl
  cmovs  %esi,%r11d
  movzbl %cl,%esi
  add    %esi,%esi
  mov    %esi,%edi
  xor    $0x1b,%edi
  test   %cl,%cl
  cmovs  %edi,%esi
  add    %r10d,%r10d
  mov    %r10d,%edi
  xor    $0x1b,%edi
  test   %al,%al
  cmovs  %edi,%r10d
  add    %r9d,%r9d
  mov    %r9d,%edi
  xor    $0x1b,%edi
  test   %bl,%bl
  cmovs  %edi,%r9d
  xor    %eax,%ecx
  mov    %eax,%edi
  xor    %edx,%eax
  xor    %ebx,%ecx
  xor    %ebx,%edi
  xor    %edx,%ebx
  movzbl %r11b,%edx
  xor    %ebp,%edi
  xor    %r11d,%ecx
  xor    %r10d,%ebx
  add    %edx,%edx
  xor    %esi,%edi
  xor    %r11d,%eax
  xor    %r9d,%ebx
  mov    %edx,%ebp
  xor    %r9d,%eax
  xor    %esi,%ecx
  xor    %r10d,%edi
  xor    $0x1b,%ebp
  test   %r11b,%r11b
  movzbl %sil,%r11d
  cmovs  %ebp,%edx
  add    %r11d,%r11d
  mov    %r11d,%ebp
  xor    $0x1b,%ebp
  test   %sil,%sil
  movzbl %r10b,%esi
  cmovs  %ebp,%r11d
  add    %esi,%esi
  mov    %esi,%ebp
  xor    $0x1b,%ebp
  test   %r10b,%r10b
  cmovs  %ebp,%esi
  movzbl %r9b,%ebp
  add    %ebp,%ebp
  mov    %ebp,%r10d
  xor    $0x1b,%r10d
  test   %r9b,%r9b
  mov    %edx,%r9d
  cmovs  %r10d,%ebp
  mov    %r11d,%r10d
  xor    %esi,%r9d
  xor    %r9d,%ecx
  xor    %ebx,%r9d
  mov    %edx,%ebx
  xor    %ebp,%r10d
  sar    $0x7,%bl
  xor    %r10d,%edi
  xor    %eax,%r10d
  mov    %edx,%eax
  and    $0x1b,%ebx
  xor    %r11d,%eax
  sar    $0x7,%r11b
  mov    %ebp,%edx
  xor    %esi,%eax
  and    $0x1b,%r11d
  sar    $0x7,%sil
  xor    %ebp,%eax
  and    $0x1b,%esi
  sar    $0x7,%dl
  add    %eax,%eax
  and    $0x1b,%edx
  xor    %ebx,%eax
  pop    %rbx
  pop    %rbp
  xor    %r11d,%eax
  xor    %esi,%eax
  xor    %edx,%eax
  xor    %eax,%ecx
  xor    %eax,%edi
  xor    %eax,%r9d
  xor    %r10d,%eax
  mov    %cl,(%r8)
  mov    %dil,0x1(%r8)
  mov    %r9b,0x2(%r8)
  mov    %al,0x3(%r8)
  ret
```

assistant: ```c
void InvMixColumn(unsigned char *column) {
  unsigned char r0, r1, r2, r3;
  r0 = column[1] ^ column[2] ^ column[3];
  r1 = column[0] ^ column[2] ^ column[3];
  r2 = column[0] ^ column[1] ^ column[3];
  r3 = column[0] ^ column[1] ^ column[2];
  column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? 0x1b : 0);
  column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? 0x1b : 0);
  column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? 0x1b : 0);
  column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? 0x1b : 0);
  r0 ^= column[0] ^ column[1];
  r1 ^= column[1] ^ column[2];
  r2 ^= column[2] ^ column[3];
  r3 ^= column[0] ^ column[3];
  column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? 0x1b : 0);
  column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? 0x1b : 0);
  column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? 0x1b : 0);
  column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? 0x1b : 0);
  r0 ^= column[0] ^ column[2];
  r1 ^= column[1] ^ column[3];
  r2 ^= column[0] ^ column[2];
  r3 ^= column[1] ^ column[3];
  column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? 0x1b : 0);
  column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? 0x1b : 0);
  column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? 0x1b : 0);
  column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? 0x1b : 0);
  column[0] ^= column[1] ^ column[2] ^ column[3];
  r0 ^= column[0];
  r1 ^= column[0];
  r2 ^= column[0];
  r3 ^= column[0];
  column[0] = r0;
  column[1] = r1;
  column[2] = r2;
  column[3] = r3;
}
```