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

```asm
<PutPostString>:
  endbr64
  push   %r15
  push   %r14
  mov    %rsi,%r14
  push   %r13
  push   %r12
  mov    %rdi,%r12
  push   %rbp
  mov    %rdx,%rbp
  push   %rbx
  sub    $0x428,%rsp
  mov    %ecx,0xc(%rsp)
  lea    0x10(%rsp),%r15
  mov    $0x400,%ecx
  mov    %r15,%rdx
  mov    %fs:0x28,%rax
  mov    %rax,0x418(%rsp)
  xor    %eax,%eax
  call   <FindPostString@plt>
  test   %eax,%eax
  js     L213
  mov    %rbp,%rdi
  mov    %eax,%r13d
  call   <strlen@plt>
  mov    %r15,%rdi
  mov    %eax,%ebx
  call   <strlen@plt>
  mov    %ebx,%edx
  mov    0xc(%rsp),%ecx
  mov    %r13d,%esi
  sub    %eax,%edx
  mov    %r12,%rdi
  call   <BufferDiff@plt>
  test   %rax,%rax
  js     L122
  test   %ebx,%ebx
  jle    L143
  movslq %r13d,%rdx
  lea    0x1(%rbp),%rdi
  lea    -0x1(%rbx),%eax
  mov    %ebx,%esi
  add    %r12,%rdx
  mov    %rdx,%rcx
  sub    %rdi,%rcx
  cmp    $0xe,%rcx
  jbe    L172
  cmp    $0x6,%eax
  jbe    L172
  cmp    $0xe,%eax
  jbe    L101
  mov    %ebx,%ecx
  xor    %eax,%eax
  shr    $0x4,%ecx
  shl    $0x4,%rcx
  nopl   0x0(%rax)
L86:
  movdqu 0x0(%rbp,%rax,1),%xmm0
  movups %xmm0,(%rdx,%rax,1)
  add    $0x10,%rax
  cmp    %rax,%rcx
  jne    L86
  mov    %ebx,%ecx
  and    $0xfffffff0,%ecx
  mov    %ecx,%eax
  cmp    %ecx,%ebx
  je     L143
  mov    %ebx,%esi
  sub    %ecx,%esi
  lea    -0x1(%rsi),%edi
  cmp    $0x6,%edi
  jbe    L23
L16:
  mov    0x0(%rbp,%rcx,1),%rdi
  mov    %rdi,(%rdx,%rcx,1)
  mov    %esi,%edx
  and    $0xfffffff8,%edx
  add    %edx,%eax
  cmp    %edx,%esi
  je     L143
L23:
  movslq %eax,%rdx
  movzbl 0x0(%rbp,%rdx,1),%ecx
  lea    0x0(%r13,%rax,1),%edx
  movslq %edx,%rdx
  mov    %cl,(%r12,%rdx,1)
  lea    0x1(%rax),%edx
  cmp    %edx,%ebx
  jle    L143
  movslq %edx,%rcx
  add    %r13d,%edx
  movzbl 0x0(%rbp,%rcx,1),%ecx
  movslq %edx,%rdx
  mov    %cl,(%r12,%rdx,1)
  lea    0x2(%rax),%edx
  cmp    %edx,%ebx
  jle    L143
  movslq %edx,%rcx
  add    %r13d,%edx
  movzbl 0x0(%rbp,%rcx,1),%ecx
  movslq %edx,%rdx
  mov    %cl,(%r12,%rdx,1)
  lea    0x3(%rax),%edx
  cmp    %edx,%ebx
  jle    L143
  movslq %edx,%rcx
  add    %r13d,%edx
  movzbl 0x0(%rbp,%rcx,1),%ecx
  movslq %edx,%rdx
  mov    %cl,(%r12,%rdx,1)
  lea    0x4(%rax),%edx
  cmp    %edx,%ebx
  jle    L143
  movslq %edx,%rcx
  add    %r13d,%edx
  movzbl 0x0(%rbp,%rcx,1),%ecx
  movslq %edx,%rdx
  mov    %cl,(%r12,%rdx,1)
  lea    0x5(%rax),%edx
  cmp    %edx,%ebx
  jle    L143
  movslq %edx,%rcx
  add    %r13d,%edx
  add    $0x6,%eax
  movzbl 0x0(%rbp,%rcx,1),%ecx
  movslq %edx,%rdx
  mov    %cl,(%r12,%rdx,1)
  cmp    %eax,%ebx
  jle    L143
  movslq %eax,%rdx
  add    %r13d,%eax
  movzbl 0x0(%rbp,%rdx,1),%edx
  cltq
  mov    %dl,(%r12,%rax,1)
L143:
  add    %r13d,%ebx
  movslq %ebx,%rbx
  movb   $0x26,(%r12,%rbx,1)
L63:
  mov    0x418(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L98
  add    $0x428,%rsp
  mov    %r13d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopw   0x0(%rax,%rax,1)
L213:
  mov    %r12,%rdi
  call   <strlen@plt>
  mov    %r14,%rdi
  mov    %eax,%ebx
  call   <strlen@plt>
  mov    %rbp,%rdi
  add    %eax,%ebx
  call   <strlen@plt>
  lea    0x2(%rbx,%rax,1),%eax
  cmp    0xc(%rsp),%eax
  jge    L122
  mov    %r12,%rdi
  lea    D4(%rip),%rsi
  call   <strcat@plt>
  mov    %r14,%rsi
  mov    %r12,%rdi
  call   <strcat@plt>
  lea    D8(%rip),%rsi
  mov    %r12,%rdi
  call   <strcat@plt>
  mov    %r12,%rdi
  call   <strlen@plt>
  mov    %rbp,%rsi
  mov    %r12,%rdi
  mov    %eax,%r13d
  call   <strcat@plt>
  jmp    L63
  nopw   0x0(%rax,%rax,1)
L172:
  mov    %ebx,%esi
  xor    %eax,%eax
  nopl   0x0(%rax)
L24:
  movzbl 0x0(%rbp,%rax,1),%ecx
  mov    %cl,(%rdx,%rax,1)
  add    $0x1,%rax
  cmp    %rsi,%rax
  jne    L24
  jmp    L143
L101:
  xor    %ecx,%ecx
  xor    %eax,%eax
  jmp    L16
L122:
  mov    $0xffffffff,%r13d
  jmp    L63
L98:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: tag: D4
datatype: string
name: parse_data
arguments: tag: D8
datatype: string

tool: D4: &

tool: D8: =

assistant: ```c
int PutPostString(char *sPost, char *sArg, char *sValue, int dMaxSize) {
  int dOrigin;
  int dValue;
  int i;
  char sAccum[1024];
  dOrigin = FindPostString(sPost, sArg, sAccum, 1024);
  if (dOrigin < 0) {
    dOrigin = strlen(sPost);
    if ((dOrigin + strlen(sArg) + strlen(sValue) + 2) >= dMaxSize) {
      return -1;
    }
    strcat(sPost, "&");
    strcat(sPost, sArg);
    strcat(sPost, "=");
    dOrigin = strlen(sPost);
    strcat(sPost, sValue);
  } else {
    dValue = strlen(sValue);
    if (BufferDiff(sPost, dOrigin, dValue - strlen(sAccum), dMaxSize) < 0) {
      return -1;
    }
    for (i = 0; i < dValue; i++) {
      sPost[dOrigin + i] = sValue[i];
    }
    sPost[dOrigin + dValue] = '&';
  }
  return dOrigin;
}
```