user: What would the C source look like for the assembly code provided here:

```asm
<jhash>:
  endbr64
  push   %r14
  push   %r13
  mov    %esi,%r13d
  push   %r12
  mov    %rdi,%r12
  push   %rbp
  push   %rbx
  lea    -0x21524111(%r13,%rdx,1),%ebx
  mov    %ebx,%r14d
  mov    %ebx,%ebp
  cmp    $0xc,%r13d
  jle    L16
  nopl   0x0(%rax)
L24:
  mov    %r12,%rdi
  sub    $0xc,%r13d
  call   <__get_unaligned_cpu32@plt>
  lea    0x10(%r12),%rdi
  add    %eax,%ebx
  call   <__get_unaligned_cpu32@plt>
  lea    0x20(%r12),%rdi
  add    $0x30,%r12
  add    %eax,%ebp
  call   <__get_unaligned_cpu32@plt>
  mov    $0x4,%esi
  add    %eax,%r14d
  mov    %r14d,%edi
  sub    %r14d,%ebx
  add    %ebp,%r14d
  call   <rol32@plt>
  mov    $0x6,%esi
  xor    %eax,%ebx
  mov    %ebx,%edi
  sub    %ebx,%ebp
  add    %r14d,%ebx
  call   <rol32@plt>
  mov    $0x8,%esi
  xor    %eax,%ebp
  mov    %ebp,%edi
  sub    %ebp,%r14d
  add    %ebx,%ebp
  call   <rol32@plt>
  mov    $0x10,%esi
  xor    %eax,%r14d
  mov    %r14d,%edi
  sub    %r14d,%ebx
  add    %ebp,%r14d
  call   <rol32@plt>
  mov    $0x13,%esi
  xor    %eax,%ebx
  mov    %ebx,%edi
  sub    %ebx,%ebp
  add    %r14d,%ebx
  call   <rol32@plt>
  mov    $0x4,%esi
  xor    %eax,%ebp
  mov    %ebp,%edi
  sub    %ebp,%r14d
  add    %ebx,%ebp
  call   <rol32@plt>
  xor    %eax,%r14d
  cmp    $0xc,%r13d
  jg     L24
L16:
  cmp    $0xc,%r13d
  ja     L2
  lea    D9(%rip),%rdx
  movslq (%rdx,%r13,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  mov    0x2c(%r12),%eax
  shl    $0x18,%eax
  add    %eax,%r14d
  mov    0x28(%r12),%eax
  shl    $0x10,%eax
  add    %eax,%r14d
  mov    0x24(%r12),%eax
  shl    $0x8,%eax
  add    %eax,%r14d
  add    0x20(%r12),%r14d
  mov    0x1c(%r12),%eax
  shl    $0x18,%eax
  add    %eax,%ebp
  mov    0x18(%r12),%eax
  shl    $0x10,%eax
  add    %eax,%ebp
  mov    0x14(%r12),%eax
  shl    $0x8,%eax
  add    %eax,%ebp
  add    0x10(%r12),%ebp
  mov    0xc(%r12),%eax
  shl    $0x18,%eax
  add    %eax,%ebx
  mov    0x8(%r12),%eax
  shl    $0x10,%eax
  add    %eax,%ebx
  mov    0x4(%r12),%eax
  shl    $0x8,%eax
  add    %eax,%ebx
  mov    %ebp,%edi
  mov    $0xe,%esi
  add    (%r12),%ebx
  xor    %ebp,%r14d
  call   <rol32@plt>
  mov    $0xb,%esi
  sub    %eax,%r14d
  mov    %r14d,%edi
  xor    %r14d,%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,%r14d
  call   <rol32@plt>
  mov    $0x4,%esi
  sub    %eax,%r14d
  mov    %r14d,%edi
  xor    %r14d,%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,%r14d
  call   <rol32@plt>
  sub    %eax,%r14d
L2:
  pop    %rbx
  mov    %r14d,%eax
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
```

assistant: ```c
uint32_t jhash(const void *key, uint32_t length, uint32_t initval) {
  uint32_t a, b, c;
  const uint8_t *k = key;
  a = b = c = 0xdeadbeef + length + initval;
  while (length > 12) {
    a += __get_unaligned_cpu32(k);
    b += __get_unaligned_cpu32(k + 4);
    c += __get_unaligned_cpu32(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;
}
```