user: Demonstrate the C code that generates the assembly output below:

```asm
<swoole_hash_jenkins>:
  endbr64
  mov    %rdi,%rcx
  mov    %rsi,%rdi
  mov    %esi,%esi
  cmp    $0xb,%edi
  jbe    L2
  mov    $0x9e3779b9,%edx
  mov    $0x9e3779b9,%r10d
  mov    $0xffffffef,%r9d
  cs nopw 0x0(%rax,%rax,1)
L21:
  movsbl 0x5(%rcx),%r8d
  movsbl 0x6(%rcx),%eax
  movsbl 0x2(%rcx),%r11d
  shl    $0x10,%eax
  shl    $0x8,%r8d
  add    %eax,%r8d
  movsbl 0x4(%rcx),%eax
  shl    $0x10,%r11d
  add    %eax,%r8d
  movsbl 0x7(%rcx),%eax
  shl    $0x18,%eax
  add    %eax,%r8d
  movzbl 0x8(%rcx),%eax
  add    %edx,%r8d
  movsbl 0x1(%rcx),%edx
  add    %r9d,%eax
  shl    $0x8,%edx
  movsbl %al,%r9d
  add    %r11d,%edx
  movsbl (%rcx),%r11d
  add    %r11d,%edx
  movsbl 0x3(%rcx),%r11d
  shl    $0x18,%r11d
  add    %r11d,%edx
  sub    %r9d,%edx
  sub    %r8d,%edx
  sub    %r9d,%r8d
  add    %r10d,%edx
  mov    %r9d,%r10d
  mov    %r8d,%r9d
  sar    $0xd,%r10d
  xor    %r10d,%edx
  mov    %edx,%r8d
  sub    %edx,%r9d
  sub    %edx,%eax
  shl    $0x8,%r8d
  xor    %r9d,%r8d
  mov    %r8d,%r9d
  sub    %r8d,%eax
  sub    %r8d,%edx
  shr    $0xd,%r9d
  xor    %r9d,%eax
  movsbl %al,%r10d
  sub    %r10d,%edx
  sub    %r10d,%r8d
  mov    %edx,%r9d
  mov    %r10d,%edx
  sar    $0xc,%edx
  xor    %r9d,%edx
  mov    %edx,%r9d
  sub    %edx,%r8d
  sub    %edx,%eax
  sub    $0xc,%esi
  shl    $0x10,%r9d
  add    $0xc,%rcx
  xor    %r8d,%r9d
  mov    %r9d,%r8d
  sub    %r9d,%eax
  sub    %r9d,%edx
  shr    $0x5,%r8d
  xor    %r8d,%eax
  mov    %eax,%r10d
  movsbl %al,%r8d
  sar    $0x3,%r10b
  sub    %r8d,%edx
  movsbl %r10b,%r10d
  xor    %edx,%r10d
  mov    %r9d,%edx
  sub    %r8d,%edx
  mov    %r10d,%r8d
  sub    %r10d,%eax
  shl    $0xa,%r8d
  sub    %r10d,%edx
  xor    %r8d,%edx
  mov    %edx,%r8d
  sub    %edx,%eax
  shr    $0xf,%r8d
  xor    %r8d,%eax
  mov    %eax,%r9d
  cmp    $0xb,%esi
  ja     L21
L5:
  add    %edi,%eax
  cmp    $0xb,%esi
  ja     L4
  lea    D0(%rip),%rdi
  movslq (%rdi,%rsi,4),%rsi
  add    %rdi,%rsi
  notrack jmp *%rsi
  nopw   0x0(%rax,%rax,1)
  movsbl 0x7(%rcx),%esi
  shl    $0x18,%esi
  add    %esi,%edx
  movsbl 0x6(%rcx),%esi
  shl    $0x10,%esi
  add    %esi,%edx
  movsbl 0x5(%rcx),%esi
  shl    $0x8,%esi
  add    %esi,%edx
  movsbl 0x4(%rcx),%esi
  add    %esi,%edx
  movsbl 0x3(%rcx),%esi
  shl    $0x18,%esi
  add    %esi,%r10d
  movsbl 0x2(%rcx),%esi
  shl    $0x10,%esi
  add    %esi,%r10d
  movsbl 0x1(%rcx),%esi
  shl    $0x8,%esi
  add    %esi,%r10d
  movsbl (%rcx),%ecx
  add    %ecx,%r10d
L4:
  movsbl %al,%ecx
  sub    %ecx,%r10d
  mov    %ecx,%esi
  sub    %edx,%r10d
  sar    $0xd,%esi
  sub    %ecx,%edx
  xor    %r10d,%esi
  mov    %esi,%ecx
  sub    %esi,%edx
  sub    %esi,%eax
  shl    $0x8,%ecx
  xor    %ecx,%edx
  mov    %edx,%ecx
  sub    %edx,%eax
  sub    %edx,%esi
  shr    $0xd,%ecx
  xor    %ecx,%eax
  movsbl %al,%edi
  mov    %edi,%ecx
  sub    %edi,%esi
  sub    %edi,%edx
  sar    $0xc,%ecx
  xor    %esi,%ecx
  mov    %edx,%esi
  mov    %ecx,%edx
  sub    %ecx,%esi
  sub    %ecx,%eax
  shl    $0x10,%edx
  xor    %esi,%edx
  mov    %edx,%esi
  sub    %edx,%eax
  sub    %edx,%ecx
  shr    $0x5,%esi
  xor    %esi,%eax
  mov    %eax,%esi
  movsbl %al,%edi
  sar    $0x3,%sil
  sub    %edi,%ecx
  sub    %edi,%edx
  movsbl %sil,%esi
  xor    %esi,%ecx
  mov    %ecx,%esi
  sub    %ecx,%edx
  shl    $0xa,%esi
  xor    %esi,%edx
  sub    %ecx,%eax
  sub    %edx,%eax
  shr    $0xf,%edx
  xor    %edx,%eax
  ret
  nopw   0x0(%rax,%rax,1)
L2:
  mov    $0xffffffef,%eax
  mov    $0x9e3779b9,%edx
  mov    $0x9e3779b9,%r10d
  jmp    L5
```

assistant: ```c
uint64_t swoole_hash_jenkins(char *key, uint32_t keylen) {
  uint64_t hashv;
  unsigned i, j, k;
  hashv = 0xfeedbeef;
  i = j = 0x9e3779b9;
  k = (unsigned)(keylen);
  while (k >= 12) {
    i += (key[0] + ((unsigned)key[1] << 8) + ((unsigned)key[2] << 16) + ((unsigned)key[3] << 24));
    j += (key[4] + ((unsigned)key[5] << 8) + ((unsigned)key[6] << 16) + ((unsigned)key[7] << 24));
    hashv += (key[8] + ((unsigned)key[9] << 8) + ((unsigned)key[10] << 16) + ((unsigned)key[11] << 24));
    do {
      i -= j;
      i -= hashv;
      i ^= (hashv >> 13);
      j -= hashv;
      j -= i;
      j ^= (i << 8);
      hashv -= i;
      hashv -= j;
      hashv ^= (j >> 13);
      i -= j;
      i -= hashv;
      i ^= (hashv >> 12);
      j -= hashv;
      j -= i;
      j ^= (i << 16);
      hashv -= i;
      hashv -= j;
      hashv ^= (j >> 5);
      i -= j;
      i -= hashv;
      i ^= (hashv >> 3);
      j -= hashv;
      j -= i;
      j ^= (i << 10);
      hashv -= i;
      hashv -= j;
      hashv ^= (j >> 15);
    } while (0);
    key += 12;
    k -= 12;
  }
  hashv += keylen;
  switch (k) {
  case 11:
    hashv += ((unsigned)key[10] << 24);
  case 10:
    hashv += ((unsigned)key[9] << 16);
  case 9:
    hashv += ((unsigned)key[8] << 8);
  case 8:
    j += ((unsigned)key[7] << 24);
  case 7:
    j += ((unsigned)key[6] << 16);
  case 6:
    j += ((unsigned)key[5] << 8);
  case 5:
    j += key[4];
  case 4:
    i += ((unsigned)key[3] << 24);
  case 3:
    i += ((unsigned)key[2] << 16);
  case 2:
    i += ((unsigned)key[1] << 8);
  case 1:
    i += key[0];
  }
  do {
    i -= j;
    i -= hashv;
    i ^= (hashv >> 13);
    j -= hashv;
    j -= i;
    j ^= (i << 8);
    hashv -= i;
    hashv -= j;
    hashv ^= (j >> 13);
    i -= j;
    i -= hashv;
    i ^= (hashv >> 12);
    j -= hashv;
    j -= i;
    j ^= (i << 16);
    hashv -= i;
    hashv -= j;
    hashv ^= (j >> 5);
    i -= j;
    i -= hashv;
    i ^= (hashv >> 3);
    j -= hashv;
    j -= i;
    j ^= (i << 10);
    hashv -= i;
    hashv -= j;
    hashv ^= (j >> 15);
  } while (0);
  return hashv;
}
```