user: What would the C source look like for the assembly code provided here:

```asm
<_base64_decode_triple>:
  endbr64
  push   %r13
  mov    %rdi,%r13
  push   %r12
  mov    %rsi,%r12
  push   %rbp
  push   %rbx
  xor    %ebx,%ebx
  sub    $0x28,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x18(%rsp)
  xor    %eax,%eax
  mov    %rsp,%rbp
L68:
  movsbl 0x0(%r13,%rbx,1),%edi
  call   <_base64_char_value@plt>
  mov    %eax,0x0(%rbp,%rbx,4)
  add    $0x1,%rbx
  cmp    $0x4,%rbx
  jne    L68
  mov    0xc(%rsp),%r10d
  test   %r10d,%r10d
  js     L36
  mov    0x8(%rsp),%r9d
  test   %r9d,%r9d
  js     L67
  mov    0x4(%rsp),%ecx
  mov    $0x3,%r8d
  test   %ecx,%ecx
  js     L67
L128:
  mov    (%rsp),%eax
  test   %eax,%eax
  js     L67
  mov    (%rsp),%eax
  lea    -0x1(%r8),%esi
  shl    $0x6,%eax
  add    0x4(%rsp),%eax
  shl    $0x6,%eax
  add    0x8(%rsp),%eax
  shl    $0x6,%eax
  add    0xc(%rsp),%eax
  cmp    $0x3,%r8d
  je     L138
  test   %eax,%eax
  lea    0xff(%rax),%edx
  lea    0x1(%r8),%ecx
  cmovs  %edx,%eax
  sar    $0x8,%eax
  cmp    $0x2,%r8d
  je     L138
L163:
  test   %eax,%eax
  lea    0xff(%rax),%edx
  cmovns %eax,%edx
  sar    $0x8,%edx
  cmp    $0x1,%ecx
  jne    L159
  test   %eax,%eax
  lea    0xffff(%rax),%edx
  cmovs  %edx,%eax
  sar    $0x10,%eax
  cmp    $0xffffffff,%esi
  je     L67
L138:
  mov    %eax,%ecx
  movslq %esi,%rdi
  sar    $0x1f,%ecx
  shr    $0x18,%ecx
  lea    (%rax,%rcx,1),%edx
  movzbl %dl,%edx
  sub    %ecx,%edx
  test   %eax,%eax
  mov    %dl,(%r12,%rdi,1)
  lea    0xff(%rax),%edx
  lea    -0x1(%rsi),%edi
  cmovs  %edx,%eax
  mov    %eax,%ecx
  sar    $0x8,%ecx
  test   %esi,%esi
  je     L191
  sar    $0x1f,%eax
  movslq %edi,%rsi
  shr    $0x18,%eax
  lea    (%rcx,%rax,1),%edx
  movzbl %dl,%edx
  sub    %eax,%edx
  test   %ecx,%ecx
  lea    0xff(%rcx),%eax
  cmovns %ecx,%eax
  mov    %dl,(%r12,%rsi,1)
  mov    %eax,%edx
  sar    $0x8,%edx
  test   %edi,%edi
  je     L191
  sar    $0x1f,%eax
  shr    $0x18,%eax
  add    %eax,%edx
  movzbl %dl,%edx
  sub    %eax,%edx
  mov    %dl,(%r12)
  jmp    L191
  nopl   0x0(%rax)
L36:
  cmpb   $0x3d,0x3(%r13)
  je     L28
L67:
  xor    %r8d,%r8d
L191:
  mov    0x18(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L212
  add    $0x28,%rsp
  mov    %r8d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  ret
  nopl   0x0(%rax)
L28:
  mov    0x8(%rsp),%r8d
  movl   $0x0,0xc(%rsp)
  test   %r8d,%r8d
  js     L186
  mov    0x4(%rsp),%esi
  mov    $0x2,%r8d
  test   %esi,%esi
  jns    L128
  jmp    L67
  cs nopw 0x0(%rax,%rax,1)
L186:
  cmpb   $0x3d,0x2(%r13)
  jne    L67
  mov    0x4(%rsp),%edi
  movl   $0x0,0x8(%rsp)
  mov    $0x1,%r8d
  test   %edi,%edi
  jns    L128
  cmpb   $0x3d,0x1(%r13)
  jne    L67
  mov    (%rsp),%edx
  movl   $0x0,0x4(%rsp)
  test   %edx,%edx
  js     L152
L145:
  mov    (%rsp),%edx
  mov    $0x1,%ecx
  mov    $0xffffffff,%esi
  shl    $0x6,%edx
  add    0x4(%rsp),%edx
  shl    $0x6,%edx
  add    0x8(%rsp),%edx
  shl    $0x6,%edx
  add    0xc(%rsp),%edx
  lea    0xff(%rdx),%eax
  cmovns %edx,%eax
  xor    %r8d,%r8d
  sar    $0x8,%eax
  jmp    L163
L152:
  cmpb   $0x3d,0x0(%r13)
  jne    L67
  movl   $0x0,(%rsp)
  jmp    L145
L159:
  mov    %edx,%eax
  jmp    L138
L212:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
int _base64_decode_triple(char quadruple[4], unsigned char *result) {
  int i, triple_value, bytes_to_decode = 3, only_equals_yet = 1;
  int char_value[4];
  for (i = 0; i < 4; i++)
    char_value[i] = _base64_char_value(quadruple[i]);
  for (i = 3; i >= 0; i--) {
    if (char_value[i] < 0) {
      if (only_equals_yet && quadruple[i] == '=') {
        char_value[i] = 0;
        bytes_to_decode--;
        continue;
      }
      return 0;
    }
    only_equals_yet = 0;
  }
  if (bytes_to_decode < 0)
    bytes_to_decode = 0;
  triple_value = char_value[0];
  triple_value *= 64;
  triple_value += char_value[1];
  triple_value *= 64;
  triple_value += char_value[2];
  triple_value *= 64;
  triple_value += char_value[3];
  for (i = bytes_to_decode; i < 3; i++)
    triple_value /= 256;
  for (i = bytes_to_decode - 1; i >= 0; i--) {
    result[i] = triple_value % 256;
    triple_value /= 256;
  }
  return bytes_to_decode;
}
```