user: What is the c source code of the assembly code below?

```asm
<main>:
  endbr64
  push   %r13
  mov    $0x65,%ecx
  push   %r12
  push   %rbp
  lea    D6(%rip),%rbp
  push   %rbx
  sub    $0x358,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x348(%rsp)
  xor    %eax,%eax
  lea    0x20(%rsp),%rbx
  lea    0x4(%rsp),%rdx
  mov    %rsp,%rsi
  mov    %rbx,%rdi
  lea    0xc(%rsp),%r8
  lea    0x14(%rsp),%r13
  lea    0x10(%rsp),%r12
  rep stos %rax,%es:(%rdi)
  lea    0x8(%rsp),%rcx
  lea    D9(%rip),%rdi
  call   <scanf@plt>
  mov    0xc(%rsp),%eax
  movd   (%rsp),%xmm0
  movd   0x4(%rsp),%xmm6
  lea    -0x1(%rax),%edx
  punpckldq %xmm6,%xmm0
  mov    %edx,0xc(%rsp)
  movq   %xmm0,0x18(%rsp)
  test   %eax,%eax
  je     L54
  nopl   0x0(%rax,%rax,1)
L91:
  mov    %r13,%rdx
  mov    %r12,%rsi
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <scanf@plt>
  movslq 0x10(%rsp),%rdx
  imul   $0x194,%rdx,%rax
  lea    (%rdx,%rdx,4),%rsi
  lea    (%rsi,%rsi,4),%rsi
  lea    (%rdx,%rsi,4),%rsi
  mov    0x20(%rsp,%rax,1),%edi
  lea    0x1(%rdi),%ecx
  mov    0x14(%rsp),%edi
  mov    %ecx,0x20(%rsp,%rax,1)
  movslq %ecx,%rcx
  mov    0x18(%rsp,%rdx,4),%eax
  add    %rsi,%rcx
  mov    %edi,0x20(%rsp,%rcx,4)
  mov    (%rsp),%ecx
  test   %edx,%edx
  je     L60
  mov    0x4(%rsp),%ecx
L60:
  imul   $0x194,%rdx,%r8
  sub    %edi,%ecx
  movslq 0x20(%rsp,%r8,1),%rsi
  cmp    %ecx,%edi
  jg     L25
  lea    (%rdx,%rdx,4),%rcx
  lea    (%rcx,%rcx,4),%rcx
  lea    (%rdx,%rcx,4),%rcx
  add    %rcx,%rsi
  mov    %edi,0x20(%rsp,%rsi,4)
  cmp    %edi,%eax
  jle    L108
  movslq 0x20(%rsp,%r8,1),%rax
  add    %rcx,%rax
  mov    %edi,0x20(%rsp,%rax,4)
  movslq 0x20(%rsp,%r8,1),%rax
  add    %rax,%rcx
  mov    %edi,%eax
  mov    %edi,0x20(%rsp,%rcx,4)
L108:
  imul   $0x194,%rdx,%rcx
  mov    %eax,0x18(%rsp,%rdx,4)
  mov    0x20(%rsp,%rcx,1),%r8d
  cmp    $0x1,%r8d
  jle    L131
  lea    -0x2(%r8),%esi
  lea    -0x1(%r8),%r9d
  cmp    $0x2,%esi
  jbe    L128
  movd   %eax,%xmm4
  lea    0x4(%rbx,%rcx,1),%rcx
  movd   %edi,%xmm5
  mov    %r9d,%eax
  shr    $0x2,%eax
  pshufd $0x0,%xmm4,%xmm1
  pshufd $0x0,%xmm5,%xmm3
  lea    -0x1(%rax),%esi
  lea    0x10(%rcx),%rax
  shl    $0x4,%rsi
  add    %rax,%rsi
  jmp    L27
  nop
L126:
  add    $0x10,%rax
L27:
  movdqu (%rcx),%xmm0
  mov    %rax,%rcx
  psubd  %xmm3,%xmm0
  movdqa %xmm0,%xmm2
  psrad  $0x1f,%xmm2
  pxor   %xmm2,%xmm0
  psubd  %xmm2,%xmm0
  movdqa %xmm0,%xmm2
  pcmpgtd %xmm1,%xmm2
  pand   %xmm2,%xmm1
  pandn  %xmm0,%xmm2
  por    %xmm2,%xmm1
  cmp    %rsi,%rax
  jne    L126
  movdqa %xmm1,%xmm2
  mov    %r9d,%esi
  psrldq $0x8,%xmm2
  and    $0xfffffffc,%esi
  movdqa %xmm2,%xmm0
  lea    0x1(%rsi),%ecx
  pcmpgtd %xmm1,%xmm0
  pand   %xmm0,%xmm1
  pandn  %xmm2,%xmm0
  por    %xmm1,%xmm0
  movdqa %xmm0,%xmm2
  psrldq $0x4,%xmm2
  movdqa %xmm2,%xmm1
  pcmpgtd %xmm0,%xmm1
  pand   %xmm1,%xmm0
  pandn  %xmm2,%xmm1
  por    %xmm0,%xmm1
  movd   %xmm1,%eax
  cmp    %r9d,%esi
  je     L62
L56:
  lea    (%rdx,%rdx,4),%r9
  movslq %ecx,%rsi
  lea    (%r9,%r9,4),%r9
  lea    (%rdx,%r9,4),%r9
  add    %r9,%rsi
  mov    0x20(%rsp,%rsi,4),%esi
  sub    %edi,%esi
  mov    %esi,%r10d
  neg    %r10d
  cmovns %r10d,%esi
  cmp    %esi,%eax
  cmovg  %esi,%eax
  lea    0x1(%rcx),%esi
  cmp    %esi,%r8d
  jle    L62
  movslq %esi,%rsi
  add    %r9,%rsi
  mov    0x20(%rsp,%rsi,4),%esi
  sub    %edi,%esi
  mov    %esi,%r10d
  neg    %r10d
  cmovns %r10d,%esi
  cmp    %esi,%eax
  cmovg  %esi,%eax
  add    $0x2,%ecx
  cmp    %ecx,%r8d
  jle    L62
  movslq %ecx,%rcx
  add    %rcx,%r9
  mov    0x20(%rsp,%r9,4),%ecx
  sub    %edi,%ecx
  mov    %ecx,%esi
  neg    %esi
  cmovns %esi,%ecx
  cmp    %ecx,%eax
  cmovg  %ecx,%eax
L62:
  mov    %eax,0x18(%rsp,%rdx,4)
L131:
  mov    0xc(%rsp),%eax
  lea    -0x1(%rax),%edx
  mov    %edx,0xc(%rsp)
  test   %eax,%eax
  jne    L91
L54:
  mov    0x18(%rsp),%esi
  imul   0x8(%rsp),%esi
  lea    D21(%rip),%rdi
  imul   0x1c(%rsp),%esi
  call   <printf@plt>
  mov    0x348(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L31
  add    $0x358,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  ret
  nopl   0x0(%rax)
L25:
  cmp    %ecx,%eax
  jle    L108
  lea    (%rdx,%rdx,4),%rax
  lea    (%rax,%rax,4),%rax
  lea    (%rdx,%rax,4),%rax
  add    %rsi,%rax
  mov    %edi,0x20(%rsp,%rax,4)
  mov    %ecx,%eax
  jmp    L108
L128:
  mov    $0x1,%ecx
  jmp    L56
L31:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: retrieve_data
arguments: data_label: D6
type: string
name: retrieve_data
arguments: data_label: D9
type: string
name: retrieve_data
arguments: data_label: D21
type: string

tool: D6: %d %d

tool: D9: %d %d %d %d

tool: D21: %d


assistant: ```c
int main(void) {
  int x, y, z, n;
  int xy[2][101] = {{0}};
  int xym[2];
  scanf("%d %d %d %d", &x, &y, &z, &n);
  xym[0] = x;
  xym[1] = y;
  while (n--) {
    int d, a, i;
    scanf("%d %d", &d, &a);
    xy[d][0]++;
    xym[d] = ((xym[d]) > (((xy[d][xy[d][0]] = a) > ((d ? y : x) - a) ? ((d ? y : x) - a) : (xy[d][xy[d][0]] = a))) ? (((xy[d][xy[d][0]] = a) > ((d ? y : x) - a) ? ((d ? y : x) - a) : (xy[d][xy[d][0]] = a))) : (xym[d]));
    for (i = 1; i < xy[d][0]; i++) {
      xym[d] = (((0 > (xy[d][i] - a) ? (-(xy[d][i] - a)) : xy[d][i] - a)) > (xym[d]) ? (xym[d]) : ((0 > (xy[d][i] - a) ? (-(xy[d][i] - a)) : xy[d][i] - a)));
    }
  }
  printf("%d\n", z * xym[0] * xym[1]);
  return 0;
}
```