user: Please show me the C implementation that matches the assembly code listed below:

```asm
<bin2Base64PlusSlashEqualsOneLine>:
  endbr64
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rdi,%r13
  mov    %esi,%ebp
  mov    %rdx,%r12
  movslq %esi,%rbx
  imul   $0x55555556,%rbx,%rbx
  shr    $0x20,%rbx
  mov    %esi,%eax
  sar    $0x1f,%eax
  sub    %eax,%ebx
  lea    (%rbx,%rbx,2),%eax
  mov    %esi,%r14d
  sub    %eax,%r14d
  mov    %r14d,%ecx
  mov    %ebx,%edx
  lea    D34(%rip),%rdi
  call   <printf@plt>
  cmp    $0x2,%ebp
  jle    L13
  mov    %r13,%rsi
  mov    %r12,%rcx
  mov    $0x0,%r8d
  lea    D22(%rip),%rdi
L30:
  mov    (%rsi),%edx
  mov    0x4(%rsi),%r9d
  mov    0x8(%rsi),%eax
  mov    %edx,%r11d
  shl    $0x6,%r11d
  sar    $0x2,%r11d
  mov    %r9d,%r10d
  sar    $0x4,%r10d
  or     %r11d,%r10d
  movslq %r10d,%r10
  mov    (%rdi,%r10,4),%r10d
  shl    $0x4,%r9d
  sar    $0x2,%r9d
  mov    %eax,%r11d
  sar    $0x6,%r11d
  or     %r11d,%r9d
  movslq %r9d,%r9
  mov    (%rdi,%r9,4),%r9d
  shl    $0x2,%eax
  sar    $0x2,%eax
  cltq
  mov    (%rdi,%rax,4),%eax
  sar    $0x2,%edx
  movslq %edx,%rdx
  mov    (%rdi,%rdx,4),%edx
  mov    %edx,(%rcx)
  mov    %r10d,0x4(%rcx)
  mov    %r9d,0x8(%rcx)
  mov    %eax,0xc(%rcx)
  add    $0x1,%r8d
  add    $0xc,%rsi
  add    $0x10,%rcx
  cmp    %r8d,%ebx
  jg     L30
L13:
  cmp    $0x2,%r14d
  je     L33
  cmp    $0x1,%r14d
  jne    L26
  movslq %ebp,%rbp
  mov    -0x4(%r13,%rbp,4),%edx
  mov    %edx,%eax
  shl    $0x6,%eax
  lea    D22(%rip),%rcx
  sar    $0x2,%eax
  cltq
  mov    (%rcx,%rax,4),%esi
  lea    0x0(,%rbx,4),%eax
  cltq
  sar    $0x2,%edx
  movslq %edx,%rdx
  mov    (%rcx,%rdx,4),%edx
  mov    %edx,(%r12,%rax,4)
  add    $0x1,%rax
  lea    0x0(,%rax,4),%rdx
  mov    %esi,(%r12,%rax,4)
  movl   $0x3d,0x4(%r12,%rdx,1)
  movl   $0x3d,0x8(%r12,%rdx,1)
  jmp    L26
L33:
  movslq %ebp,%rbp
  shl    $0x2,%rbp
  mov    -0x8(%r13,%rbp,1),%edx
  mov    -0x4(%r13,%rbp,1),%eax
  mov    %edx,%edi
  shl    $0x6,%edi
  sar    $0x2,%edi
  lea    D22(%rip),%rsi
  mov    %eax,%ecx
  sar    $0x4,%ecx
  or     %edi,%ecx
  movslq %ecx,%rcx
  mov    (%rsi,%rcx,4),%ecx
  shl    $0x4,%eax
  sar    $0x2,%eax
  cltq
  mov    (%rsi,%rax,4),%edi
  lea    0x0(,%rbx,4),%eax
  cltq
  sar    $0x2,%edx
  movslq %edx,%rdx
  mov    (%rsi,%rdx,4),%edx
  mov    %edx,(%r12,%rax,4)
  add    $0x1,%rax
  lea    0x0(,%rax,4),%rdx
  mov    %ecx,(%r12,%rax,4)
  mov    %edi,0x4(%r12,%rdx,1)
  movl   $0x3d,0x8(%r12,%rdx,1)
L26:
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
```

tool_calls: name: retrieve_data
arguments: data_label: D34
type_infered: string
name: retrieve_data
arguments: data_label: D22
type_infered: string

tool: D34: inlen %i  sets %i  leftover %i


tool: D22: A

assistant: ```c
void bin2Base64PlusSlashEqualsOneLine(uint8_t *in, uint64_t inLen, uint8_t *out) {
  static uint8_t sixBitsToHex[64] = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f};
  static uint8_t padding = 0x3d;
  uint64_t setsOfThree;
  uint64_t charsLeftOver;
  uint8_t outSet[4];
  uint8_t inSet[3];
  uint8_t inUnit;
  setsOfThree = inLen / 3;
  charsLeftOver = inLen % 3;
  printf("inlen %i  sets %i  leftover %i\n", (int)inLen, (int)setsOfThree, (int)charsLeftOver);
  fflush;
  for (int i = 0; i < setsOfThree; i++) {
    inSet[0] = in[i * 3];
    inSet[1] = in[i * 3 + 1];
    inSet[2] = in[i * 3 + 2];
    inUnit = inSet[0] >> 2;
    outSet[0] = sixBitsToHex[inUnit];
    inUnit = inSet[0] << 6;
    inUnit = inUnit >> 2;
    inUnit |= inSet[1] >> 4;
    outSet[1] = sixBitsToHex[inUnit];
    inUnit = inSet[1] << 4;
    inUnit = inUnit >> 2;
    inUnit |= (inSet[2] >> 6);
    outSet[2] = sixBitsToHex[inUnit];
    inUnit = inSet[2] << 2;
    inUnit = inUnit >> 2;
    outSet[3] = sixBitsToHex[inUnit];
    out[i * 4] = outSet[0];
    out[i * 4 + 1] = outSet[1];
    out[i * 4 + 2] = outSet[2];
    out[i * 4 + 3] = outSet[3];
  };
  if (charsLeftOver == 2) {
    inSet[0] = in[inLen - 2];
    inSet[1] = in[inLen - 1];
    inUnit = inSet[0] >> 2;
    outSet[0] = sixBitsToHex[inUnit];
    inUnit = inSet[0] << 6;
    inUnit = inUnit >> 2;
    inUnit |= inSet[1] >> 4;
    outSet[1] = sixBitsToHex[inUnit];
    inUnit = inSet[1] << 4;
    inUnit = inUnit >> 2;
    outSet[2] = sixBitsToHex[inUnit];
    outSet[3] = padding;
    out[setsOfThree * 4] = outSet[0];
    out[setsOfThree * 4 + 1] = outSet[1];
    out[setsOfThree * 4 + 2] = outSet[2];
    out[setsOfThree * 4 + 3] = outSet[3];
  };
  if (charsLeftOver == 1) {
    inSet[0] = in[inLen - 1];
    inUnit = inSet[0] >> 2;
    outSet[0] = sixBitsToHex[inUnit];
    inUnit = inSet[0] << 6;
    inUnit = inUnit >> 2;
    outSet[1] = sixBitsToHex[inUnit];
    outSet[2] = padding;
    outSet[3] = padding;
    out[setsOfThree * 4] = outSet[0];
    out[setsOfThree * 4 + 1] = outSet[1];
    out[setsOfThree * 4 + 2] = outSet[2];
    out[setsOfThree * 4 + 3] = outSet[3];
  };
}
```