user: 请将以下的汇编代码转换成C语言代码：

```asm
<ChkMurMur3>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  mov    %rdi,-0x38(%rbp)
  mov    %esi,-0x3c(%rbp)
  mov    %edx,-0x40(%rbp)
  mov    -0x40(%rbp),%eax
  mov    %eax,-0x24(%rbp)
  mov    -0x3c(%rbp),%eax
  lea    0x3(%rax),%edx
  test   %eax,%eax
  cmovs  %edx,%eax
  sar    $0x2,%eax
  mov    %eax,-0x18(%rbp)
  mov    -0x38(%rbp),%rax
  mov    %rax,-0x10(%rbp)
  movl   $0x0,-0x1c(%rbp)
  jmp    L12
L33:
  mov    -0x1c(%rbp),%eax
  cltq
  lea    0x0(,%rax,4),%rdx
  mov    -0x10(%rbp),%rax
  add    %rdx,%rax
  mov    (%rax),%eax
  mov    %eax,-0x14(%rbp)
  mov    D11(%rip),%eax
  mov    -0x14(%rbp),%edx
  imul   %edx,%eax
  mov    %eax,-0x14(%rbp)
  mov    D59(%rip),%eax
  mov    -0x14(%rbp),%edx
  mov    %edx,%esi
  mov    %eax,%ecx
  shl    %cl,%esi
  mov    D59(%rip),%edx
  mov    $0x20,%eax
  sub    %edx,%eax
  mov    -0x14(%rbp),%edx
  mov    %eax,%ecx
  sar    %cl,%edx
  mov    %edx,%eax
  or     %esi,%eax
  mov    %eax,-0x14(%rbp)
  mov    D0(%rip),%eax
  mov    -0x14(%rbp),%edx
  imul   %edx,%eax
  mov    %eax,-0x14(%rbp)
  mov    -0x14(%rbp),%eax
  xor    %eax,-0x24(%rbp)
  mov    D67(%rip),%eax
  mov    -0x24(%rbp),%edx
  mov    %edx,%esi
  mov    %eax,%ecx
  shl    %cl,%esi
  mov    D67(%rip),%edx
  mov    $0x20,%eax
  sub    %edx,%eax
  mov    -0x24(%rbp),%edx
  mov    %eax,%ecx
  sar    %cl,%edx
  mov    %edx,%eax
  or     %eax,%esi
  mov    %esi,%edx
  mov    D71(%rip),%eax
  imul   %eax,%edx
  mov    D96(%rip),%eax
  add    %edx,%eax
  mov    %eax,-0x24(%rbp)
  addl   $0x1,-0x1c(%rbp)
L12:
  mov    -0x1c(%rbp),%eax
  cmp    -0x18(%rbp),%eax
  jl     L33
  mov    -0x18(%rbp),%eax
  shl    $0x2,%eax
  cltq
  lea    0x0(,%rax,4),%rdx
  mov    -0x38(%rbp),%rax
  add    %rdx,%rax
  mov    %rax,-0x8(%rbp)
  movl   $0x0,-0x20(%rbp)
  mov    -0x3c(%rbp),%eax
  and    $0x3,%eax
  cmp    $0x3,%eax
  je     L27
  cmp    $0x3,%eax
  jg     L37
  cmp    $0x1,%eax
  je     L22
  cmp    $0x2,%eax
  je     L53
  jmp    L37
L27:
  mov    -0x8(%rbp),%rax
  add    $0x8,%rax
  mov    (%rax),%eax
  shl    $0x10,%eax
  xor    %eax,-0x20(%rbp)
L53:
  mov    -0x8(%rbp),%rax
  add    $0x4,%rax
  mov    (%rax),%eax
  shl    $0x8,%eax
  xor    %eax,-0x20(%rbp)
L22:
  mov    -0x8(%rbp),%rax
  mov    (%rax),%eax
  xor    %eax,-0x20(%rbp)
  mov    D11(%rip),%eax
  mov    -0x20(%rbp),%edx
  imul   %edx,%eax
  mov    %eax,-0x20(%rbp)
  mov    D59(%rip),%eax
  mov    -0x20(%rbp),%edx
  mov    %edx,%esi
  mov    %eax,%ecx
  shl    %cl,%esi
  mov    D59(%rip),%edx
  mov    $0x20,%eax
  sub    %edx,%eax
  mov    -0x20(%rbp),%edx
  mov    %eax,%ecx
  sar    %cl,%edx
  mov    %edx,%eax
  or     %esi,%eax
  mov    %eax,-0x20(%rbp)
  mov    D0(%rip),%eax
  mov    -0x20(%rbp),%edx
  imul   %edx,%eax
  mov    %eax,-0x20(%rbp)
  mov    -0x20(%rbp),%eax
  xor    %eax,-0x24(%rbp)
L37:
  mov    -0x3c(%rbp),%eax
  xor    %eax,-0x24(%rbp)
  mov    -0x24(%rbp),%eax
  sar    $0x10,%eax
  xor    %eax,-0x24(%rbp)
  mov    -0x24(%rbp),%eax
  imul   $0x85ebca6b,%eax,%eax
  mov    %eax,-0x24(%rbp)
  mov    -0x24(%rbp),%eax
  sar    $0xd,%eax
  xor    %eax,-0x24(%rbp)
  mov    -0x24(%rbp),%eax
  imul   $0xc2b2ae35,%eax,%eax
  mov    %eax,-0x24(%rbp)
  mov    -0x24(%rbp),%eax
  sar    $0x10,%eax
  xor    %eax,-0x24(%rbp)
  mov    -0x24(%rbp),%eax
  pop    %rbp
  ret
```

tool_calls: name: parse_data
arguments: tag: D11
type_infered: byte[4]
name: parse_data
arguments: tag: D59
type_infered: byte[4]
name: parse_data
arguments: tag: D0
type_infered: byte[4]
name: parse_data
arguments: tag: D67
type_infered: byte[4]
name: parse_data
arguments: tag: D71
type_infered: byte[4]
name: parse_data
arguments: tag: D96
type_infered: byte[4]

tool: {"D11": [0x51,0x2d,0x9e,0xcc]}

tool: {"D59": [0x0f,0x00,0x00,0x00]}

tool: {"D0": [0x93,0x35,0x87,0x1b]}

tool: {"D67": [0x0d,0x00,0x00,0x00]}

tool: {"D71": [0x05,0x00,0x00,0x00]}

tool: {"D96": [0x64,0x6b,0x54,0xe6]}

assistant: ```c
uint32_t ChkMurMur3(const void *buf, uint32_t len, uint32_t seed) {
  static const uint32_t c1 = 0xcc9e2d51;
  static const uint32_t c2 = 0x1b873593;
  static const uint32_t r1 = 15;
  static const uint32_t r2 = 13;
  static const uint32_t m = 5;
  static const uint32_t n = 0xe6546b64;
  const uint8_t *tail;
  uint32_t hash = seed, k, k1;
  const int nblocks = len / 4;
  const uint32_t *blocks = (const uint32_t *)buf;
  int i;
  for (i = 0; i < nblocks; i++) {
    k = blocks[i];
    k *= c1;
    k = (k << r1) | (k >> (32 - r1));
    k *= c2;
    hash ^= k;
    hash = ((hash << r2) | (hash >> (32 - r2))) * m + n;
  }
  tail = (const uint8_t *)(((const uint8_t *)buf) + nblocks * 4);
  k1 = 0;
  switch (len & 3) {
  case 3:
    k1 ^= tail[2] << 16;
  case 2:
    k1 ^= tail[1] << 8;
  case 1:
    k1 ^= tail[0];
    k1 *= c1;
    k1 = (k1 << r1) | (k1 >> (32 - r1));
    k1 *= c2;
    hash ^= k1;
  }
  hash ^= len;
  hash ^= (hash >> 16);
  hash *= 0x85ebca6b;
  hash ^= (hash >> 13);
  hash *= 0xc2b2ae35;
  hash ^= (hash >> 16);
  return hash;
}
```