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

```asm
<addBinary>:
  endbr64
  push   %r13
  push   %r12
  push   %rbp
  mov    %rdi,%rbp
  push   %rbx
  mov    %rsi,%rbx
  sub    $0x8,%rsp
  call   <strlen@plt>
  mov    %rbx,%rdi
  mov    %rax,%r13
  call   <strlen@plt>
  mov    $0x1,%esi
  cmp    %rax,%r13
  mov    %rax,%rdi
  mov    %rax,%r12
  cmovae %r13,%rdi
  add    $0x2,%edi
  call   <calloc@plt>
  mov    %rax,%r8
  test   %rax,%rax
  je     L75
  mov    %rax,%rsi
  lea    0x0(%rbp,%r13,1),%r9
  lea    (%rbx,%r12,1),%rcx
  xor    %eax,%eax
  lea    D5(%rip),%rdi
  jmp    L30
  nopl   0x0(%rax)
L31:
  mov    %r10,%rsi
  mov    %r11,%r9
L30:
  mov    %r9,%r11
  cmp    %rbp,%r9
  jbe    L157
  movsbl -0x1(%r9),%edx
  lea    -0x1(%r9),%r11
  lea    -0x30(%rax,%rdx,1),%eax
L157:
  mov    %eax,%edx
  cmp    %rbx,%rcx
  jbe    L118
  movsbl -0x1(%rcx),%eax
  sub    $0x1,%rcx
  lea    -0x30(%rdx,%rax,1),%edx
L118:
  mov    %edx,%eax
  mov    %edx,%r10d
  shr    $0x1f,%r10d
  shr    $0x1f,%eax
  add    %edx,%eax
  add    %r10d,%edx
  and    $0x1,%edx
  sar    %eax
  sub    %r10d,%edx
  cmp    %rbp,%r11
  lea    0x1(%rsi),%r10
  movslq %edx,%rdx
  sete   %r12b
  movzbl (%rdi,%rdx,1),%edx
  mov    %dl,(%rsi)
  cmp    %rbx,%rcx
  jne    L78
  test   %r12b,%r12b
  jne    L130
L78:
  cmp    %rbp,%r9
  ja     L31
  cmp    %rcx,%rbx
  jae    L19
L10:
  movsbl -0x1(%rcx),%edx
  lea    -0x1(%rcx),%rsi
  lea    0x1(%r10),%r9
  lea    -0x30(%rax,%rdx,1),%edx
  mov    %edx,%eax
  mov    %edx,%ecx
  shr    $0x1f,%ecx
  shr    $0x1f,%eax
  add    %edx,%eax
  add    %ecx,%edx
  and    $0x1,%edx
  sar    %eax
  sub    %ecx,%edx
  movslq %edx,%rdx
  movzbl (%rdi,%rdx,1),%edx
  mov    %dl,(%r10)
  cmp    %rsi,%rbx
  jne    L111
  test   %r12b,%r12b
  jne    L159
L111:
  mov    %rsi,%rcx
L80:
  mov    %r9,%r10
  cmp    %rcx,%rbx
  jb     L10
L19:
  mov    %eax,%edx
  mov    %eax,%esi
  lea    0x1(%r10),%r9
  shr    $0x1f,%esi
  shr    $0x1f,%edx
  add    %eax,%edx
  add    %esi,%eax
  and    $0x1,%eax
  sar    %edx
  sub    %esi,%eax
  cltq
  movzbl (%rdi,%rax,1),%eax
  mov    %al,(%r10)
  mov    %edx,%eax
  cmp    %rcx,%rbx
  jne    L80
  test   %r12b,%r12b
  je     L80
L159:
  mov    %r10,%rsi
  mov    %r9,%r10
L130:
  test   %eax,%eax
  je     L79
  cltq
  lea    0x2(%rsi),%rdx
  mov    %r10,%rsi
  movzbl (%rdi,%rax,1),%eax
  mov    %al,(%r10)
  mov    %rdx,%r10
L79:
  movb   $0x0,(%r10)
  cmp    %r8,%r10
  jbe    L75
  mov    %r8,%rax
  cs nopw 0x0(%rax,%rax,1)
L135:
  movzbl (%rax),%edx
  movzbl (%rsi),%ecx
  sub    $0x1,%rsi
  add    $0x1,%rax
  mov    %cl,-0x1(%rax)
  mov    %dl,0x1(%rsi)
  lea    0x1(%rsi),%rdx
  cmp    %rdx,%rax
  jb     L135
L75:
  add    $0x8,%rsp
  mov    %r8,%rax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  ret
```

tool_calls: name: parse_data
arguments: data_tag: D5
type_guessed: string

tool: D5: 01

assistant: ```c
char *addBinary(char *left, char *right) {
  const char BASE = 2;
  const size_t leftCount = strlen(left);
  const size_t rightCount = strlen(right);
  const size_t resultCount = 1 + (((leftCount) > (rightCount)) ? (leftCount) : (rightCount));
  char *buffer = (char *)calloc(1 + resultCount, sizeof(*buffer));
  if (buffer) {
    const char *pleft = &left[leftCount];
    const char *pright = &right[rightCount];
    char *presult = buffer;
    int carry = 0;
    while (1) {
      const int leftBit = pleft > left ? *--pleft - '0' : 0;
      const int rightBit = pright > right ? *--pright - '0' : 0;
      const int total = carry + leftBit + rightBit;
      carry = total / BASE;
      *presult = "01"[total % BASE];
      ++presult;
      if (pleft == left && pright == right) {
        break;
      }
    }
    if (carry) {
      *presult++ = "01"[carry];
    }
    *presult = '\0';
    for (char *begin = buffer, *end = presult; begin < end--; ++begin) {
      const char temp = *begin;
      *begin = *end;
      *end = temp;
    }
  }
  return buffer;
}
```