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

```asm
<DoArithmEval>:
  endbr64
  push   %r15
  push   %r14
  mov    %rcx,%r14
  push   %r13
  mov    %rdi,%r13
  push   %r12
  mov    %edx,%r12d
  push   %rbp
  mov    %esi,%ebp
  push   %rbx
  sub    $0x28,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x18(%rsp)
  xor    %eax,%eax
  cmp    %edx,%esi
  jge    L1403
  movslq %esi,%rbx
  add    %rdi,%rbx
  jmp    L1427
  nopl   (%rax)
L1702:
  add    $0x1,%ebp
  add    $0x1,%rbx
  cmp    %ebp,%r12d
  je     L1401
L1427:
  movsbl (%rbx),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L1702
  cmp    %r12d,%ebp
  jge    L1403
  movslq %r12d,%rax
  lea    -0x1(%r13,%rax,1),%rbx
  jmp    L1062
L1431:
  sub    $0x1,%r12d
  sub    $0x1,%rbx
  cmp    %r12d,%ebp
  je     L1401
L1062:
  movsbl (%rbx),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L1431
L1652:
  lea    0x8(%rsp),%r15
  lea    0x4(%rsp),%rbx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D68(%rip),%rcx
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  je     L1548
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L730
  xchg   %ax,%ax
L1401:
  xor    %eax,%eax
L1252:
  mov    0x18(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L1565
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   (%rax)
L1548:
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D90(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  je     L1388
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  test   %eax,%eax
  je     L1533
  mov    0x10(%rsp),%edx
  xor    %eax,%eax
  test   %edx,%edx
  setne  %al
  jmp    L1533
  nopl   0x0(%rax,%rax,1)
L1388:
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D61(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  je     L1460
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  or     0x10(%rsp),%eax
L1533:
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
  nop
L730:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  or     0x10(%rsp),%eax
  setne  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1403:
  cmp    %ebp,%r12d
  jne    L1652
  jmp    L1401
  nopl   (%rax)
L1460:
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D58(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L196
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D158(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  je     L158
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  and    0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L196:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  xor    0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L158:
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D150(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L1657
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D92(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L1270
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D123(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L956
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D120(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L1674
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D0(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L90
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D176(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L1267
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D42(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L755
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D208(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  je     L116
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x10(%rsp),%eax
  add    0xc(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
  cs nopw 0x0(%rax,%rax,1)
L1657:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L11
L1602:
  mov    0x4(%rsp),%eax
  cmp    %eax,%ebp
  jl     L652
  jmp    L1115
  nopl   (%rax)
L1659:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L1115
L652:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L1659
L1115:
  mov    0x8(%rsp),%eax
  cmp    %r12d,%eax
  jl     L316
  jmp    L331
  nopl   0x0(%rax)
L1386:
  add    $0x1,%eax
  mov    %eax,0x8(%rsp)
  cmp    %r12d,%eax
  jge    L331
L316:
  cltq
  movsbl 0x0(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  mov    0x8(%rsp),%eax
  jne    L1386
L331:
  mov    0x4(%rsp),%edx
  sub    %eax,%r12d
  sub    %ebp,%edx
  cmp    %r12d,%edx
  je     L688
  movl   $0x1,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1270:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L968
L147:
  mov    0x4(%rsp),%eax
  cmp    %eax,%ebp
  jl     L192
  jmp    L776
  nopw   0x0(%rax,%rax,1)
L397:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L776
L192:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L397
L776:
  mov    0x8(%rsp),%eax
  cmp    %r12d,%eax
  jl     L514
  jmp    L490
  nopl   0x0(%rax)
L65:
  add    $0x1,%eax
  mov    %eax,0x8(%rsp)
  cmp    %r12d,%eax
  jge    L490
L514:
  cltq
  movsbl 0x0(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  mov    0x8(%rsp),%eax
  jne    L65
L490:
  mov    0x4(%rsp),%edx
  sub    %eax,%r12d
  sub    %ebp,%edx
  cmp    %r12d,%edx
  je     L4
  movl   $0x0,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L956:
  lea    D9(%rip),%rdi
  call   <bug@plt>
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L351
L1336:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L530
  jmp    L775
  xchg   %ax,%ax
L8:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L775
L530:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L8
L775:
  mov    0x8(%rsp),%ebx
  cmp    %r12d,%ebx
  jl     L1621
  jmp    L1704
  nopl   0x0(%rax)
L455:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%ebx
  mov    %ebx,0x8(%rsp)
  cmp    %r12d,%ebx
  jge    L1704
L1621:
  movslq %ebx,%rbx
  movsbl 0x0(%r13,%rbx,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L455
  mov    0x8(%rsp),%ebx
L1704:
  movslq %ebp,%rdi
  add    %r13,%rdi
  call   <strdup@plt>
  movslq %ebx,%rdi
  mov    %rax,%r15
  mov    0x4(%rsp),%eax
  add    %r13,%rdi
  sub    %ebp,%eax
  cltq
  movb   $0x0,(%r15,%rax,1)
  call   <strdup@plt>
  xor    %edx,%edx
  mov    %r15,%rsi
  mov    %rax,%rbp
  mov    %r12d,%eax
  sub    %ebx,%eax
  mov    %rbp,%rdi
  cltq
  movb   $0x0,0x0(%rbp,%rax,1)
  call   <fnmatch@plt>
  mov    %r15,%rdi
  test   %rax,%rax
  sete   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  call   <free@plt>
  mov    %rbp,%rdi
  call   <free@plt>
  mov    $0x1,%eax
  jmp    L1252
L968:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L147
L1417:
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  sete   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L11:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1602
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setne  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1674:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L1416
L1343:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L1713
  jmp    L243
  nopw   0x0(%rax,%rax,1)
L1022:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L243
L1713:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L1022
L243:
  movslq 0x8(%rsp),%rax
  mov    %eax,%edx
  cmp    %r12d,%eax
  jl     L1762
  jmp    L1707
  nopw   0x0(%rax,%rax,1)
L1769:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%edx
  mov    %edx,0x8(%rsp)
  cmp    %r12d,%edx
  jge    L1010
L1762:
  movslq %edx,%rdx
  movsbl 0x0(%r13,%rdx,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L1769
  movslq 0x8(%rsp),%rax
L1707:
  mov    0x4(%rsp),%edx
  mov    %r12d,%ecx
  movslq %ebp,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  sub    %eax,%ecx
  sub    %ebp,%edx
  cmp    %ecx,%edx
  cmovg  %ecx,%edx
  add    %r13,%rdi
  call   <strncmp@plt>
  mov    %eax,%r8d
  mov    $0x1,%eax
  test   %r8d,%r8d
  jg     L1533
  mov    $0x0,%eax
  jne    L1533
  mov    0x4(%rsp),%eax
  sub    0x8(%rsp),%r12d
  sub    %ebp,%eax
  cmp    %r12d,%eax
  setge  %al
  movzbl %al,%eax
  jmp    L1533
L1416:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1343
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setge  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1010:
  movslq %edx,%rax
  jmp    L1707
L351:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1336
  jmp    L1417
L90:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L345
L297:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L1297
  jmp    L1074
  cs nopw 0x0(%rax,%rax,1)
L122:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L1074
L1297:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L122
L1074:
  movslq 0x8(%rsp),%rax
  mov    %eax,%edx
  cmp    %r12d,%eax
  jl     L428
  jmp    L626
  nop
L467:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%edx
  mov    %edx,0x8(%rsp)
  cmp    %r12d,%edx
  jge    L1557
L428:
  movslq %edx,%rdx
  movsbl 0x0(%r13,%rdx,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L467
  movslq 0x8(%rsp),%rax
L626:
  mov    0x4(%rsp),%edx
  mov    %r12d,%ecx
  movslq %ebp,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  sub    %eax,%ecx
  sub    %ebp,%edx
  cmp    %ecx,%edx
  cmovg  %ecx,%edx
  add    %r13,%rdi
  call   <strncmp@plt>
  mov    %eax,%r8d
  mov    $0x1,%eax
  test   %r8d,%r8d
  jg     L1533
  mov    $0x0,%eax
  jne    L1533
  mov    0x4(%rsp),%eax
  sub    0x8(%rsp),%r12d
  sub    %ebp,%eax
  cmp    %r12d,%eax
  setg   %al
  movzbl %al,%eax
  jmp    L1533
L116:
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D174(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  je     L454
  mov    0x4(%rsp),%edx
  cmp    %ebp,%edx
  je     L454
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  sub    0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L755:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L1561
L156:
  mov    0x4(%rsp),%eax
  cmp    %eax,%ebp
  jl     L1795
  jmp    L1053
  nopl   (%rax)
L181:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L1053
L1795:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L181
L1053:
  movslq 0x8(%rsp),%rax
  mov    %eax,%edx
  cmp    %r12d,%eax
  jl     L701
  jmp    L1754
  nop
L1756:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%edx
  mov    %edx,0x8(%rsp)
  cmp    %r12d,%edx
  jge    L1578
L701:
  movslq %edx,%rdx
  movsbl 0x0(%r13,%rdx,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L1756
  movslq 0x8(%rsp),%rax
L1754:
  mov    0x4(%rsp),%edx
  mov    %r12d,%ecx
  movslq %ebp,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  sub    %eax,%ecx
  sub    %ebp,%edx
  cmp    %ecx,%edx
  cmovg  %ecx,%edx
  add    %r13,%rdi
  call   <strncmp@plt>
  mov    %eax,%r8d
  mov    $0x1,%eax
  test   %r8d,%r8d
  js     L1533
  mov    $0x0,%eax
  jne    L1533
  mov    0x4(%rsp),%eax
  sub    0x8(%rsp),%r12d
  sub    %ebp,%eax
  cmp    %r12d,%eax
  setl   %al
  movzbl %al,%eax
  jmp    L1533
L1267:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L517
L431:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L452
  jmp    L984
  cs nopw 0x0(%rax,%rax,1)
L329:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L984
L452:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L329
L984:
  movslq 0x8(%rsp),%rax
  mov    %eax,%edx
  cmp    %r12d,%eax
  jl     L1191
  jmp    L548
  nop
L703:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%edx
  mov    %edx,0x8(%rsp)
  cmp    %r12d,%edx
  jge    L13
L1191:
  movslq %edx,%rdx
  movsbl 0x0(%r13,%rdx,1),%edi
  call   <iswhite@plt>
  test   %rax,%rax
  jne    L703
  movslq 0x8(%rsp),%rax
L548:
  mov    0x4(%rsp),%edx
  mov    %r12d,%ecx
  movslq %ebp,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  sub    %eax,%ecx
  sub    %ebp,%edx
  cmp    %ecx,%edx
  cmovg  %ecx,%edx
  add    %r13,%rdi
  call   <strncmp@plt>
  mov    %eax,%r8d
  mov    $0x1,%eax
  test   %r8d,%r8d
  js     L1533
  mov    $0x0,%eax
  jne    L1533
  mov    0x4(%rsp),%eax
  sub    0x8(%rsp),%r12d
  sub    %ebp,%eax
  cmp    %r12d,%eax
  setle  %al
  movzbl %al,%eax
  jmp    L1533
L688:
  cltq
  movslq %ebp,%rdi
  add    %r13,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  call   <strncmp@plt>
  test   %eax,%eax
  setne  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1557:
  movslq %edx,%rax
  jmp    L626
L4:
  cltq
  movslq %ebp,%rdi
  add    %r13,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  call   <strncmp@plt>
  test   %eax,%eax
  sete   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L517:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L431
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setle  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1578:
  movslq %edx,%rax
  jmp    L1754
L13:
  movslq %edx,%rax
  jmp    L548
L1561:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L156
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setl   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L345:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L297
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setg   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1565:
  call   <__stack_chk_fail@plt>
L454:
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D141(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  je     L1490
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  imul   0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1490:
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D218(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  je     L1630
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x10(%rsp),%ebx
  test   %ebx,%ebx
  je     L396
L1082:
  mov    0xc(%rsp),%eax
  cltd
  idiv   %ebx
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1630:
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D114(%rip),%rcx
  mov    %r12d,%edx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %rax,%rax
  jne    L1682
  movslq %ebp,%r15
  add    %r13,%r15
  movzbl (%r15),%eax
  cmp    $0x7e,%al
  je     L1568
  cmp    $0x21,%al
  je     L236
  cmp    $0x2d,%al
  je     L148
  lea    D36(%rip),%rbx
  mov    %rbx,%rdi
  call   <strlen@plt>
  mov    %rbx,%rsi
  mov    %r15,%rdi
  mov    %eax,%edx
  call   <strncmp@plt>
  mov    %eax,%r8d
  movslq %r12d,%rax
  test   %r8d,%r8d
  jne    L1642
  cmpb   $0x29,-0x1(%r13,%rax,1)
  jne    L1401
  lea    D192(%rip),%rdi
  sub    %ebp,%r12d
  call   <strlen@plt>
  sub    %eax,%r12d
  mov    $0x1,%eax
  mov    %r12d,(%r14)
  jmp    L1252
L396:
  lea    D154(%rip),%rdi
  call   <bug@plt>
  jmp    L1082
L1642:
  cmpb   $0x28,(%r15)
  jne    L25
  cmpb   $0x29,-0x1(%r13,%rax,1)
  jne    L1401
  lea    -0x1(%r12),%edx
  lea    0x1(%rbp),%esi
  mov    %r14,%rcx
  mov    %r13,%rdi
  call   <DoArithmEval>
  jmp    L1252
L148:
  lea    0xc(%rsp),%rcx
  lea    0x1(%rbp),%esi
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  neg    %eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1568:
  lea    0xc(%rsp),%rcx
  lea    0x1(%rbp),%esi
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0xc(%rsp),%eax
  not    %eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L1682:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  mov    0x10(%rsp),%ebx
  test   %ebx,%ebx
  je     L727
L1056:
  mov    0xc(%rsp),%eax
  cltd
  idiv   %ebx
  mov    $0x1,%eax
  mov    %edx,(%r14)
  jmp    L1252
L236:
  lea    0xc(%rsp),%rcx
  lea    0x1(%rbp),%esi
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1401
  xor    %eax,%eax
  cmpl   $0x0,0xc(%rsp)
  sete   %al
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L1252
L25:
  add    %rax,%r13
  xor    %edx,%edx
  lea    0x10(%rsp),%rsi
  mov    %r15,%rdi
  movzbl 0x0(%r13),%ebx
  movb   $0x0,0x0(%r13)
  call   <strtol@plt>
  mov    %eax,(%r14)
  xor    %eax,%eax
  cmp    %r13,0x10(%rsp)
  mov    %bl,0x0(%r13)
  sete   %al
  jmp    L1252
L727:
  lea    D154(%rip),%rdi
  call   <bug@plt>
  jmp    L1056
```

tool_calls: name: parse_data
arguments: data_tag: D68
type_infered: string
name: parse_data
arguments: data_tag: D90
type_infered: string
name: parse_data
arguments: data_tag: D61
type_infered: string
name: parse_data
arguments: data_tag: D58
type_infered: string
name: parse_data
arguments: data_tag: D158
type_infered: string
name: parse_data
arguments: data_tag: D150
type_infered: string
name: parse_data
arguments: data_tag: D92
type_infered: string
name: parse_data
arguments: data_tag: D123
type_infered: string
name: parse_data
arguments: data_tag: D120
type_infered: string
name: parse_data
arguments: data_tag: D0
type_infered: string
name: parse_data
arguments: data_tag: D176
type_infered: string
name: parse_data
arguments: data_tag: D42
type_infered: string
name: parse_data
arguments: data_tag: D208
type_infered: string
name: parse_data
arguments: data_tag: D9
type_infered: string
name: parse_data
arguments: data_tag: D174
type_infered: string
name: parse_data
arguments: data_tag: D141
type_infered: string
name: parse_data
arguments: data_tag: D218
type_infered: string
name: parse_data
arguments: data_tag: D114
type_infered: string
name: parse_data
arguments: data_tag: D36
type_infered: string
name: parse_data
arguments: data_tag: D192
type_infered: string
name: parse_data
arguments: data_tag: D154
type_infered: string

tool: D68: ||

tool: D90: &&

tool: D61: |

tool: D58: ^

tool: D158: &

tool: D150: !=

tool: D92: ==

tool: D123: =~

tool: D120: >=

tool: D0: >

tool: D176: <=

tool: D42: <

tool: D208: +

tool: D9: globbing support has not been compiled in

tool: D174: -

tool: D141: *

tool: D218: /

tool: D114: %

tool: D36: length(

tool: D192: length()

tool: D154: Division by zero in expression

assistant: ```c
int DoArithmEval(char *buf, int pos1, int pos2, int *result) {
  int spl1, spl2, result1, result2, l;
  char c, *p;
  while ((pos1 < pos2) && iswhite(buf[pos1]))
    pos1++;
  while ((pos1 < pos2) && iswhite(buf[pos2 - 1]))
    pos2--;
  if (pos1 == pos2)
    return 0;
  if (SpliceInfix(buf, pos1, pos2, "||", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 || result2;
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "&&", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 && result2;
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "|", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 | result2;
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "^", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 ^ result2;
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "&", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 & result2;
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "!=", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2)) {
      while ((pos1 < spl1) && iswhite(buf[spl1 - 1]))
        spl1--;
      while ((pos2 > spl2) && iswhite(buf[spl2]))
        spl2++;
      if (spl1 - pos1 != pos2 - spl2)
        *result = 1;
      else
        *result = (strncmp(buf + pos1, buf + spl2, spl1 - pos1) != 0);
    } else
      *result = (result1 != result2);
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "==", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2)) {
      while ((pos1 < spl1) && iswhite(buf[spl1 - 1]))
        spl1--;
      while ((pos2 > spl2) && iswhite(buf[spl2]))
        spl2++;
      if (spl1 - pos1 != pos2 - spl2)
        *result = 0;
      else
        *result = (strncmp(buf + pos1, buf + spl2, spl1 - pos1) == 0);
    } else
      *result = (result1 == result2);
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "=~", &spl1, &spl2)) {
    bug("globbing support has not been compiled in");
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2)) {
      char *str1, *str2;
      while ((pos1 < spl1) && iswhite(buf[spl1 - 1]))
        spl1--;
      while ((pos2 > spl2) && iswhite(buf[spl2]))
        spl2++;
      str1 = strdup(buf + pos1);
      str1[spl1 - pos1] = '\0';
      str2 = strdup(buf + spl2);
      str2[pos2 - spl2] = '\0';
      *result = (fnmatch(str2, str1, 0) == 0);
      free(str1);
      free(str2);
    } else
      *result = (result1 == result2);
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, ">=", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2)) {
      while ((pos1 < spl1) && iswhite(buf[spl1 - 1]))
        spl1--;
      while ((pos2 > spl2) && iswhite(buf[spl2]))
        spl2++;
      l = spl1 - pos1;
      if (l > pos2 - spl2)
        l = pos2 - spl2;
      result1 = strncmp(buf + pos1, buf + spl2, l);
      *result = (result1 > 0) || ((result1 == 0) && (spl1 - pos1 >= pos2 - spl2));
    } else
      *result = (result1 >= result2);
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, ">", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2)) {
      while ((pos1 < spl1) && iswhite(buf[spl1 - 1]))
        spl1--;
      while ((pos2 > spl2) && iswhite(buf[spl2]))
        spl2++;
      l = spl1 - pos1;
      if (l > pos2 - spl2)
        l = pos2 - spl2;
      result1 = strncmp(buf + pos1, buf + spl2, l);
      *result = (result1 > 0) || ((result1 == 0) && (spl1 - pos1 > pos2 - spl2));
    } else
      *result = (result1 > result2);
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "<=", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2)) {
      while ((pos1 < spl1) && iswhite(buf[spl1 - 1]))
        spl1--;
      while ((pos2 > spl2) && iswhite(buf[spl2]))
        spl2++;
      l = spl1 - pos1;
      if (l > pos2 - spl2)
        l = pos2 - spl2;
      result1 = strncmp(buf + pos1, buf + spl2, l);
      *result = (result1 < 0) || ((result1 == 0) && (spl1 - pos1 <= pos2 - spl2));
    } else
      *result = (result1 <= result2);
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "<", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2)) {
      while ((pos1 < spl1) && iswhite(buf[spl1 - 1]))
        spl1--;
      while ((pos2 > spl2) && iswhite(buf[spl2]))
        spl2++;
      l = spl1 - pos1;
      if (l > pos2 - spl2)
        l = pos2 - spl2;
      result1 = strncmp(buf + pos1, buf + spl2, l);
      *result = (result1 < 0) || ((result1 == 0) && (spl1 - pos1 < pos2 - spl2));
    } else
      *result = (result1 < result2);
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "+", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 + result2;
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "-", &spl1, &spl2))
    if (spl1 != pos1) {
      if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
        return 0;
      *result = result1 - result2;
      return 1;
    }
  if (SpliceInfix(buf, pos1, pos2, "*", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 * result2;
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "/", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    if (result2 == 0)
      bug("Division by zero in expression");
    *result = result1 / result2;
    return 1;
  }
  if (SpliceInfix(buf, pos1, pos2, "%", &spl1, &spl2)) {
    if (!DoArithmEval(buf, pos1, spl1, &result1) || !DoArithmEval(buf, spl2, pos2, &result2))
      return 0;
    if (result2 == 0)
      bug("Division by zero in expression");
    *result = result1 % result2;
    return 1;
  }
  if (buf[pos1] == '~') {
    if (!DoArithmEval(buf, pos1 + 1, pos2, &result1))
      return 0;
    *result = ~result1;
    return 1;
  }
  if (buf[pos1] == '!') {
    if (!DoArithmEval(buf, pos1 + 1, pos2, &result1))
      return 0;
    *result = !result1;
    return 1;
  }
  if (buf[pos1] == '-') {
    if (!DoArithmEval(buf, pos1 + 1, pos2, &result1))
      return 0;
    *result = -result1;
    return 1;
  }
  if (strncmp(buf + pos1, "length(", strlen("length(")) == 0) {
    if (buf[pos2 - 1] != ')')
      return 0;
    *result = pos2 - pos1 - strlen("length()");
    return 1;
  }
  if (buf[pos1] == '(') {
    if (buf[pos2 - 1] != ')')
      return 0;
    return DoArithmEval(buf, pos1 + 1, pos2 - 1, result);
  }
  c = buf[pos2];
  buf[pos2] = 0;
  *result = (int)strtol(buf + pos1, &p, 0);
  buf[pos2] = c;
  return (p == buf + pos2);
}
```