user: Converte this assembly snippet into its equivalent C code:

```asm
<_jenkins_hashword2>:
  endbr64
  mov    (%rdx),%eax
  mov    %rsi,%r8
  mov    %rdx,%rsi
  lea    -0x21524111(%rax,%r8,4),%edx
  mov    (%rcx),%eax
  mov    %edx,%r10d
  add    %edx,%eax
  cmp    $0x3,%r8
  jbe    L13
  nopl   (%rax)
L3:
  add    0x8(%rdi),%eax
  add    (%rdi),%edx
  mov    %eax,%r9d
  mov    %eax,%r11d
  sub    %eax,%edx
  add    0x4(%rdi),%r10d
  sar    $0x1c,%r11d
  shl    $0x4,%r9d
  add    %r10d,%eax
  or     %r11d,%r9d
  xor    %r9d,%edx
  mov    %edx,%r9d
  mov    %edx,%r11d
  sub    %edx,%r10d
  sar    $0x1a,%r11d
  shl    $0x6,%r9d
  or     %r11d,%r9d
  lea    (%rdx,%rax,1),%r11d
  xor    %r10d,%r9d
  mov    %r9d,%edx
  mov    %r9d,%r10d
  sub    %r9d,%eax
  sar    $0x18,%r10d
  shl    $0x8,%edx
  or     %r10d,%edx
  lea    (%r9,%r11,1),%r10d
  xor    %eax,%edx
  mov    %edx,%eax
  mov    %edx,%r9d
  sub    %edx,%r11d
  sar    $0x10,%r9d
  shl    $0x10,%eax
  or     %r9d,%eax
  lea    (%rdx,%r10,1),%r9d
  xor    %r11d,%eax
  mov    %eax,%edx
  mov    %eax,%r11d
  sub    %eax,%r10d
  sar    $0xd,%r11d
  shl    $0x13,%edx
  or     %r11d,%edx
  xor    %edx,%r10d
  lea    (%rax,%r9,1),%edx
  mov    %r10d,%r11d
  mov    %r10d,%eax
  sub    %r10d,%r9d
  shl    $0x4,%eax
  sar    $0x1c,%r11d
  or     %r11d,%eax
  sub    $0x3,%r8
  add    %edx,%r10d
  add    $0xc,%rdi
  xor    %r9d,%eax
  cmp    $0x3,%r8
  ja     L3
L13:
  cmp    $0x2,%r8
  je     L42
  cmp    $0x3,%r8
  je     L18
  cmp    $0x1,%r8
  je     L11
  mov    %eax,(%rsi)
  mov    %r10d,(%rcx)
  ret
  nopl   0x0(%rax,%rax,1)
L18:
  add    0x8(%rdi),%eax
L42:
  add    0x4(%rdi),%r10d
L11:
  add    (%rdi),%edx
  mov    %r10d,%r8d
  mov    %r10d,%edi
  xor    %r10d,%eax
  sar    $0x12,%r8d
  shl    $0xe,%edi
  or     %r8d,%edi
  sub    %edi,%eax
  mov    %eax,%edi
  mov    %eax,%r8d
  xor    %eax,%edx
  sar    $0x15,%r8d
  shl    $0xb,%edi
  or     %r8d,%edi
  sub    %edi,%edx
  mov    %edx,%edi
  mov    %edx,%r8d
  xor    %edx,%r10d
  sar    $0x7,%r8d
  shl    $0x19,%edi
  or     %r8d,%edi
  sub    %edi,%r10d
  mov    %r10d,%edi
  mov    %r10d,%r8d
  xor    %r10d,%eax
  sar    $0x10,%r8d
  shl    $0x10,%edi
  or     %r8d,%edi
  sub    %edi,%eax
  mov    %eax,%edi
  mov    %eax,%r8d
  xor    %eax,%edx
  shl    $0x4,%edi
  sar    $0x1c,%r8d
  or     %r8d,%edi
  sub    %edi,%edx
  mov    %edx,%edi
  xor    %edx,%r10d
  sar    $0x12,%edx
  shl    $0xe,%edi
  or     %edi,%edx
  sub    %edx,%r10d
  mov    %r10d,%edx
  mov    %r10d,%edi
  xor    %r10d,%eax
  shl    $0x18,%edx
  sar    $0x8,%edi
  or     %edi,%edx
  sub    %edx,%eax
  mov    %eax,(%rsi)
  mov    %r10d,(%rcx)
  ret
```

assistant: ```c
void _jenkins_hashword2(const uint32_t *k, size_t length, uint32_t *pc, uint32_t *pb) {
  uint32_t a, b, c;
  a = b = c = 0xdeadbeef + ((uint32_t)(length << 2)) + *pc;
  c += *pb;
  while (length > 3) {
    a += k[0];
    b += k[1];
    c += k[2];
    {
      a -= c;
      a ^= (((c) << (4)) | ((c) >> (32 - (4))));
      c += b;
      b -= a;
      b ^= (((a) << (6)) | ((a) >> (32 - (6))));
      a += c;
      c -= b;
      c ^= (((b) << (8)) | ((b) >> (32 - (8))));
      b += a;
      a -= c;
      a ^= (((c) << (16)) | ((c) >> (32 - (16))));
      c += b;
      b -= a;
      b ^= (((a) << (19)) | ((a) >> (32 - (19))));
      a += c;
      c -= b;
      c ^= (((b) << (4)) | ((b) >> (32 - (4))));
      b += a;
    };
    length -= 3;
    k += 3;
  }
  switch (length) {
  case 3:
    c += k[2];
  case 2:
    b += k[1];
  case 1:
    a += k[0];
    {
      c ^= b;
      c -= (((b) << (14)) | ((b) >> (32 - (14))));
      a ^= c;
      a -= (((c) << (11)) | ((c) >> (32 - (11))));
      b ^= a;
      b -= (((a) << (25)) | ((a) >> (32 - (25))));
      c ^= b;
      c -= (((b) << (16)) | ((b) >> (32 - (16))));
      a ^= c;
      a -= (((c) << (4)) | ((c) >> (32 - (4))));
      b ^= a;
      b -= (((a) << (14)) | ((a) >> (32 - (14))));
      c ^= b;
      c -= (((b) << (24)) | ((b) >> (32 - (24))));
    };
  case 0:
    break;
  }
  *pc = c;
  *pb = b;
}
```