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

```asm
<hashbig>:
  endbr64
  lea    -0x21524111(%rdx,%rsi,1),%eax
  mov    %rdi,%rcx
  mov    %rsi,%rdi
  mov    %eax,%r8d
  mov    %eax,%edx
  cmp    $0xc,%rsi
  jbe    L8
L17:
  mov    (%rcx),%esi
  shl    $0x18,%esi
  add    %esi,%r8d
  mov    0x8(%rcx),%esi
  shl    $0x10,%esi
  add    %r8d,%esi
  mov    0x10(%rcx),%r8d
  shl    $0x8,%r8d
  add    %esi,%r8d
  mov    0x20(%rcx),%esi
  add    0x18(%rcx),%r8d
  shl    $0x18,%esi
  add    %edx,%esi
  mov    0x28(%rcx),%edx
  shl    $0x10,%edx
  add    %esi,%edx
  mov    0x30(%rcx),%esi
  shl    $0x8,%esi
  add    %edx,%esi
  mov    0x40(%rcx),%edx
  add    0x38(%rcx),%esi
  shl    $0x18,%edx
  add    %edx,%eax
  mov    0x48(%rcx),%edx
  shl    $0x10,%edx
  add    %eax,%edx
  mov    0x50(%rcx),%eax
  shl    $0x8,%eax
  add    %edx,%eax
  add    0x58(%rcx),%eax
  mov    %eax,%edx
  mov    %eax,%r9d
  sub    %eax,%r8d
  add    %esi,%eax
  sar    $0x1c,%r9d
  shl    $0x4,%edx
  or     %r9d,%edx
  xor    %r8d,%edx
  sub    %edx,%esi
  mov    %edx,%r9d
  mov    %esi,%r8d
  mov    %edx,%esi
  sar    $0x1a,%r9d
  shl    $0x6,%esi
  or     %r9d,%esi
  xor    %r8d,%esi
  lea    (%rdx,%rax,1),%r8d
  mov    %esi,%r9d
  mov    %esi,%edx
  sub    %esi,%eax
  add    %r8d,%esi
  sar    $0x18,%r9d
  shl    $0x8,%edx
  sub    $0xc,%rdi
  add    $0x60,%rcx
  or     %r9d,%edx
  xor    %edx,%eax
  mov    %r8d,%edx
  mov    %eax,%r9d
  mov    %eax,%r8d
  sub    %eax,%edx
  add    %esi,%eax
  sar    $0x10,%r9d
  shl    $0x10,%r8d
  or     %r9d,%r8d
  xor    %edx,%r8d
  mov    %r8d,%edx
  mov    %r8d,%r9d
  sub    %r8d,%esi
  add    %eax,%r8d
  sar    $0xd,%r9d
  shl    $0x13,%edx
  or     %r9d,%edx
  xor    %esi,%edx
  mov    %edx,%esi
  mov    %edx,%r9d
  sub    %edx,%eax
  add    %r8d,%edx
  shl    $0x4,%esi
  sar    $0x1c,%r9d
  or     %r9d,%esi
  xor    %esi,%eax
  cmp    $0xc,%rdi
  ja     L17
L8:
  lea    D3(%rip),%r9
  movslq (%r9,%rdi,4),%rsi
  add    %r9,%rsi
  notrack jmp *%rsi
  add    0x58(%rcx),%eax
  mov    0x50(%rcx),%esi
  shl    $0x8,%esi
  add    %esi,%eax
  mov    0x48(%rcx),%esi
  shl    $0x10,%esi
  add    %esi,%eax
  mov    0x40(%rcx),%esi
  shl    $0x18,%esi
  add    %esi,%eax
  add    0x38(%rcx),%edx
  mov    0x30(%rcx),%esi
  shl    $0x8,%esi
  add    %esi,%edx
  mov    0x28(%rcx),%esi
  shl    $0x10,%esi
  add    %esi,%edx
  mov    0x20(%rcx),%esi
  shl    $0x18,%esi
  add    %esi,%edx
  add    0x18(%rcx),%r8d
  mov    0x10(%rcx),%esi
  shl    $0x8,%esi
  add    %esi,%r8d
  mov    0x8(%rcx),%esi
  shl    $0x10,%esi
  add    %esi,%r8d
  mov    %edx,%esi
  mov    %edx,%edi
  xor    %edx,%eax
  mov    (%rcx),%rcx
  sar    $0x12,%edi
  shl    $0xe,%esi
  or     %edi,%esi
  shl    $0x18,%ecx
  sub    %esi,%eax
  add    %r8d,%ecx
  mov    %eax,%esi
  mov    %eax,%edi
  xor    %eax,%ecx
  sar    $0x15,%edi
  shl    $0xb,%esi
  or     %edi,%esi
  sub    %esi,%ecx
  mov    %ecx,%esi
  mov    %ecx,%edi
  xor    %ecx,%edx
  sar    $0x7,%edi
  shl    $0x19,%esi
  or     %edi,%esi
  sub    %esi,%edx
  mov    %edx,%esi
  mov    %edx,%edi
  xor    %edx,%eax
  sar    $0x10,%edi
  shl    $0x10,%esi
  or     %edi,%esi
  sub    %esi,%eax
  mov    %eax,%esi
  mov    %eax,%edi
  xor    %eax,%ecx
  shl    $0x4,%esi
  sar    $0x1c,%edi
  or     %edi,%esi
  sub    %esi,%ecx
  mov    %ecx,%esi
  xor    %ecx,%edx
  sar    $0x12,%ecx
  shl    $0xe,%esi
  or     %esi,%ecx
  sub    %ecx,%edx
  mov    %edx,%ecx
  xor    %edx,%eax
  sar    $0x8,%edx
  shl    $0x18,%ecx
  or     %ecx,%edx
  sub    %edx,%eax
  ret
```

assistant: ```c
uint32_t hashbig(const void *key, size_t length, uint32_t initval) {
  uint32_t a, b, c;
  union {
    const void *ptr;
    size_t i;
  } u;
  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
  u.ptr = key;
  if (0 && ((u.i & 0x3) == 0)) {
    const uint32_t *k = (const uint32_t *)key;
    while (length > 12) {
      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 -= 12;
      k += 3;
    }
    switch (length) {
    case 12:
      c += k[2];
      b += k[1];
      a += k[0];
      break;
    case 11:
      c += k[2] & 0xffffff00;
      b += k[1];
      a += k[0];
      break;
    case 10:
      c += k[2] & 0xffff0000;
      b += k[1];
      a += k[0];
      break;
    case 9:
      c += k[2] & 0xff000000;
      b += k[1];
      a += k[0];
      break;
    case 8:
      b += k[1];
      a += k[0];
      break;
    case 7:
      b += k[1] & 0xffffff00;
      a += k[0];
      break;
    case 6:
      b += k[1] & 0xffff0000;
      a += k[0];
      break;
    case 5:
      b += k[1] & 0xff000000;
      a += k[0];
      break;
    case 4:
      a += k[0];
      break;
    case 3:
      a += k[0] & 0xffffff00;
      break;
    case 2:
      a += k[0] & 0xffff0000;
      break;
    case 1:
      a += k[0] & 0xff000000;
      break;
    case 0:
      return c;
    }
  } else {
    const uint8_t *k = (const uint8_t *)key;
    while (length > 12) {
      a += ((uint32_t)k[0]) << 24;
      a += ((uint32_t)k[1]) << 16;
      a += ((uint32_t)k[2]) << 8;
      a += ((uint32_t)k[3]);
      b += ((uint32_t)k[4]) << 24;
      b += ((uint32_t)k[5]) << 16;
      b += ((uint32_t)k[6]) << 8;
      b += ((uint32_t)k[7]);
      c += ((uint32_t)k[8]) << 24;
      c += ((uint32_t)k[9]) << 16;
      c += ((uint32_t)k[10]) << 8;
      c += ((uint32_t)k[11]);
      {
        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 -= 12;
      k += 12;
    }
    switch (length) {
    case 12:
      c += k[11];
    case 11:
      c += ((uint32_t)k[10]) << 8;
    case 10:
      c += ((uint32_t)k[9]) << 16;
    case 9:
      c += ((uint32_t)k[8]) << 24;
    case 8:
      b += k[7];
    case 7:
      b += ((uint32_t)k[6]) << 8;
    case 6:
      b += ((uint32_t)k[5]) << 16;
    case 5:
      b += ((uint32_t)k[4]) << 24;
    case 4:
      a += k[3];
    case 3:
      a += ((uint32_t)k[2]) << 8;
    case 2:
      a += ((uint32_t)k[1]) << 16;
    case 1:
      a += ((uint32_t)k[0]) << 24;
      break;
    case 0:
      return c;
    }
  }
  {
    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))));
  };
  return c;
}
```