user: Translate the below assembly code into C programming language:

```asm
<ss_rollingHamming>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rsi,%r11
  mov    %edx,-0x4(%rsp)
  mov    %r8d,%r14d
  mov    %r9,%r12
  sub    %edx,%ecx
  lea    0x1(%rcx),%ebx
  movslq %ebx,%rbx
  movslq %r8d,%r13
  lea    (%rbx,%r13,1),%r15
  lea    (%r9,%r15,4),%rcx
  lea    (%r9,%r13,4),%rbp
  cmp    %rbp,%rcx
  jbe    L62
  mov    %rsi,%r8
  movslq %edx,%r9
  add    %rsi,%r9
  mov    %rbp,%rdx
  jmp    L24
L162:
  addl   $0x1,(%rdx)
L39:
  add    $0x1,%rax
  cmp    %r10,%rax
  je     L43
L186:
  movzbl (%rsi,%rax,1),%ecx
  cmp    %cl,(%rdi,%rax,1)
  jne    L162
  jmp    L39
L43:
  mov    -0x10(%rsp),%rcx
L138:
  add    $0x4,%rdx
  add    $0x1,%r8
  add    $0x1,%r9
  cmp    %rdx,%rcx
  jbe    L62
L24:
  mov    %r8,%rsi
  cmp    %r9,%r8
  jae    L138
  mov    %r9,%r10
  sub    %r8,%r10
  mov    $0x0,%eax
  mov    %rcx,-0x10(%rsp)
  jmp    L186
L62:
  test   %r14d,%r14d
  jle    L4
  test   %rbp,%rbp
  je     L17
  movslq -0x4(%rsp),%r9
  mov    %r9,%rsi
  sub    %r13,%rsi
  mov    $0x0,%edx
  add    %rdi,%r9
  jmp    L133
L22:
  add    $0x1,%rax
  cmp    %rax,%rsi
  je     L0
L52:
  movzbl (%r11,%rax,1),%r14d
  cmp    %r14b,(%r8,%rax,1)
  je     L22
  addl   $0x1,(%rdx)
  jmp    L22
L0:
  add    $0x4,%rdx
  add    $0x1,%rsi
  cmp    %rdx,%rbp
  jbe    L17
L133:
  mov    %r9,%r8
  sub    %rsi,%r8
  lea    (%r11,%rsi,1),%rax
  cmp    %rax,%r11
  jae    L0
  mov    $0x0,%eax
  jmp    L52
L17:
  add    %r15,%r13
  lea    (%r12,%r13,4),%r9
  cmp    %r9,%rcx
  jae    L4
  movslq -0x4(%rsp),%rdx
  mov    %rbx,%rax
  sub    %rdx,%rax
  lea    0x1(%r11,%rax,1),%r8
  sub    $0x1,%rdx
  add    %rbx,%r11
  jmp    L222
L131:
  add    $0x1,%rax
  cmp    %rdx,%rax
  je     L214
L227:
  movzbl (%rsi,%rax,1),%ebx
  cmp    %bl,(%rdi,%rax,1)
  je     L131
  addl   $0x1,(%rcx)
  jmp    L131
L214:
  add    $0x4,%rcx
  add    $0x1,%r8
  sub    $0x1,%rdx
  cmp    %rcx,%r9
  jbe    L4
L222:
  mov    %r8,%rsi
  cmp    %r11,%r8
  jae    L214
  mov    $0x0,%eax
  jmp    L227
L4:
  mov    $0x0,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

assistant: ```c
int ss_rollingHamming(const char *s1, const char *s2, int len1, int len2, int overlap, int *hamming_arr_ptr) {
  const int num_positions = len2 - len1 + 1;
  int *hamming_arr_ptr_lim = hamming_arr_ptr + num_positions + overlap;
  int *ham_ptr;
  char *s1_ptr;
  char *s2_ptr;
  char *s2_start_ptr = (char *)s2;
  int i;
  for (ham_ptr = hamming_arr_ptr + overlap; ham_ptr < hamming_arr_ptr_lim; ham_ptr++) {
    s1_ptr = (char *)s1;
    s2_ptr = s2_start_ptr++;
    const char *s2_ptr_lim = s2_ptr + len1;
    while (s2_ptr < s2_ptr_lim) {
      if (*s1_ptr++ != *s2_ptr++) {
        (*ham_ptr)++;
      }
    }
  }
  if (overlap > 0) {
    i = overlap;
    hamming_arr_ptr_lim = hamming_arr_ptr + overlap;
    for (ham_ptr = 0; ham_ptr < hamming_arr_ptr_lim; ham_ptr++, i--) {
      s1_ptr = (char *)s1 + i;
      s2_ptr = (char *)s2;
      const char *s2_ptr_lim = s2_ptr + len1 - i;
      while (s2_ptr < s2_ptr_lim) {
        if (*s1_ptr++ != *s2_ptr++) {
          (*ham_ptr)++;
        }
      }
    }
    i = 1;
    hamming_arr_ptr_lim = hamming_arr_ptr + num_positions + 2 * overlap;
    for (ham_ptr = hamming_arr_ptr + num_positions + overlap; ham_ptr < hamming_arr_ptr_lim; ham_ptr++, i++) {
      s1_ptr = (char *)s1;
      s2_ptr = (char *)s2 + num_positions - len1 + i;
      const char *s2_ptr_lim = s2_ptr + len1 - i;
      while (s2_ptr < s2_ptr_lim) {
        if (*s1_ptr++ != *s2_ptr++) {
          (*ham_ptr)++;
        }
      }
    }
  }
  return 0;
}
```