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

```asm
<jhash>:
  endbr64
  push   %r14
  mov    %esi,%r14d
  push   %r13
  mov    %rdi,%r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0x61c8ffff(%r14,%rdx,1),%ebx
  mov    %ebx,%r12d
  mov    %ebx,%ebp
  cmp    $0xc,%r14d
  jle    L21
  nopl   0x0(%rax)
L20:
  add    0x20(%r13),%r12d
  add    0x0(%r13),%ebx
  sub    $0xc,%r14d
  add    $0x30,%r13
  mov    %r12d,%edi
  mov    $0x4,%esi
  add    -0x20(%r13),%ebp
  sub    %r12d,%ebx
  call   <rol32@plt>
  mov    $0x6,%esi
  add    %ebp,%r12d
  xor    %eax,%ebx
  mov    %ebx,%edi
  sub    %ebx,%ebp
  add    %r12d,%ebx
  call   <rol32@plt>
  mov    $0x8,%esi
  xor    %eax,%ebp
  mov    %ebp,%edi
  sub    %ebp,%r12d
  add    %ebx,%ebp
  call   <rol32@plt>
  mov    $0x10,%esi
  xor    %eax,%r12d
  mov    %r12d,%edi
  sub    %r12d,%ebx
  add    %ebp,%r12d
  call   <rol32@plt>
  mov    $0x13,%esi
  xor    %eax,%ebx
  mov    %ebx,%edi
  sub    %ebx,%ebp
  add    %r12d,%ebx
  call   <rol32@plt>
  mov    $0x4,%esi
  xor    %eax,%ebp
  mov    %ebp,%edi
  sub    %ebp,%r12d
  add    %ebx,%ebp
  call   <rol32@plt>
  xor    %eax,%r12d
  cmp    $0xc,%r14d
  jg     L20
L21:
  cmp    $0xc,%r14d
  ja     L12
  lea    D7(%rip),%rdx
  movslq (%rdx,%r14,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  mov    0x2c(%r13),%eax
  shl    $0x18,%eax
  add    %eax,%r12d
  mov    0x28(%r13),%eax
  shl    $0x10,%eax
  add    %eax,%r12d
  mov    0x24(%r13),%eax
  shl    $0x8,%eax
  add    %eax,%r12d
  add    0x20(%r13),%r12d
  mov    0x1c(%r13),%eax
  shl    $0x18,%eax
  add    %eax,%ebp
  mov    0x18(%r13),%eax
  shl    $0x10,%eax
  add    %eax,%ebp
  mov    0x14(%r13),%eax
  shl    $0x8,%eax
  add    %eax,%ebp
  add    0x10(%r13),%ebp
  mov    0xc(%r13),%eax
  shl    $0x18,%eax
  add    %eax,%ebx
  mov    0x8(%r13),%eax
  shl    $0x10,%eax
  add    %eax,%ebx
  mov    0x4(%r13),%eax
  shl    $0x8,%eax
  add    %eax,%ebx
  mov    %ebp,%edi
  mov    $0xe,%esi
  add    0x0(%r13),%ebx
  xor    %ebp,%r12d
  call   <rol32@plt>
  mov    $0xb,%esi
  sub    %eax,%r12d
  mov    %r12d,%edi
  xor    %r12d,%ebx
  call   <rol32@plt>
  mov    $0x19,%esi
  sub    %eax,%ebx
  mov    %ebx,%edi
  xor    %ebx,%ebp
  call   <rol32@plt>
  mov    $0x10,%esi
  sub    %eax,%ebp
  mov    %ebp,%edi
  xor    %ebp,%r12d
  call   <rol32@plt>
  mov    $0x4,%esi
  sub    %eax,%r12d
  mov    %r12d,%edi
  xor    %r12d,%ebx
  call   <rol32@plt>
  mov    %ebx,%edi
  mov    $0xe,%esi
  sub    %eax,%edi
  xor    %edi,%ebp
  call   <rol32@plt>
  mov    %ebp,%edi
  mov    $0x18,%esi
  sub    %eax,%edi
  xor    %edi,%r12d
  call   <rol32@plt>
  sub    %eax,%r12d
L12:
  pop    %rbx
  mov    %r12d,%eax
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
```

assistant: ```c
uint32_t jhash(const void *key, uint32_t length, uint32_t initval) {
  const uint8_t *k = key;
  uint32_t a, b, c;
  a = b = c = 0x9e370001UL + length + initval;
  while (length > 12) {
    a += *k;
    b += *(k + 4);
    c += *(k + 8);
    {
      a -= c;
      a ^= rol32(c, 4);
      c += b;
      b -= a;
      b ^= rol32(a, 6);
      a += c;
      c -= b;
      c ^= rol32(b, 8);
      b += a;
      a -= c;
      a ^= rol32(c, 16);
      c += b;
      b -= a;
      b ^= rol32(a, 19);
      a += c;
      c -= b;
      c ^= rol32(b, 4);
      b += a;
    };
    length -= 12;
    k += 12;
  }
  switch (length) {
  case 12:
    c += (uint32_t)k[11] << 24;
  case 11:
    c += (uint32_t)k[10] << 16;
  case 10:
    c += (uint32_t)k[9] << 8;
  case 9:
    c += k[8];
  case 8:
    b += (uint32_t)k[7] << 24;
  case 7:
    b += (uint32_t)k[6] << 16;
  case 6:
    b += (uint32_t)k[5] << 8;
  case 5:
    b += k[4];
  case 4:
    a += (uint32_t)k[3] << 24;
  case 3:
    a += (uint32_t)k[2] << 16;
  case 2:
    a += (uint32_t)k[1] << 8;
  case 1:
    a += k[0];
    {
      c ^= b;
      c -= rol32(b, 14);
      a ^= c;
      a -= rol32(c, 11);
      b ^= a;
      b -= rol32(a, 25);
      c ^= b;
      c -= rol32(b, 16);
      a ^= c;
      a -= rol32(c, 4);
      b ^= a;
      b -= rol32(a, 14);
      c ^= b;
      c -= rol32(b, 24);
    };
  case 0:
    break;
  }
  return c;
}
```