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

```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    L131
  movslq %esi,%rbx
  add    %rdi,%rbx
  jmp    L1040
  nopl   (%rax)
L171:
  add    $0x1,%ebp
  add    $0x1,%rbx
  cmp    %ebp,%r12d
  je     L35
L1040:
  movsbl (%rbx),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L171
  cmp    %ebp,%r12d
  jle    L131
  movslq %r12d,%rax
  lea    -0x1(%r13,%rax,1),%rbx
  jmp    L1032
  nopl   0x0(%rax)
L907:
  sub    $0x1,%r12d
  sub    $0x1,%rbx
  cmp    %ebp,%r12d
  je     L35
L1032:
  movsbl (%rbx),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L907
L192:
  lea    0x8(%rsp),%r15
  lea    0x4(%rsp),%rbx
  xor    %eax,%eax
  mov    %r12d,%edx
  mov    %r15,%r9
  mov    %rbx,%r8
  lea    D32(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  je     L436
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L856
  nopl   0x0(%rax,%rax,1)
L35:
  xor    %eax,%eax
L530:
  mov    0x18(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L288
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   (%rax)
L436:
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D138(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  je     L1411
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  test   %eax,%eax
  je     L1443
  mov    0x10(%rsp),%edx
  xor    %eax,%eax
  test   %edx,%edx
  setne  %al
L1443:
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
  nopw   0x0(%rax,%rax,1)
L1411:
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D181(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  je     L889
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  or     0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L856:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  or     0x10(%rsp),%eax
  setne  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L131:
  cmp    %ebp,%r12d
  jne    L192
  jmp    L35
  nopl   (%rax)
L889:
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D173(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L975
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D58(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  je     L877
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  and    0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L975:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  xor    0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L877:
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D112(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L1375
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D139(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L126
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D2(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L18
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D199(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L1648
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D97(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L627
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D104(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L1701
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D93(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L586
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D66(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  je     L259
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x10(%rsp),%eax
  add    0xc(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L1375:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L1607
L1450:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L494
  jmp    L169
  nopl   (%rax)
L1237:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L169
L494:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L1237
L169:
  mov    0x8(%rsp),%eax
  cmp    %r12d,%eax
  jl     L1339
  jmp    L1002
  nopl   (%rax)
L1195:
  add    $0x1,%eax
  mov    %eax,0x8(%rsp)
  cmp    %r12d,%eax
  jge    L1002
L1339:
  cltq
  movsbl 0x0(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  mov    0x8(%rsp),%eax
  jne    L1195
L1002:
  mov    0x4(%rsp),%edx
  sub    %eax,%r12d
  sub    %ebp,%edx
  cmp    %r12d,%edx
  je     L711
  movl   $0x1,(%r14)
  mov    $0x1,%eax
  jmp    L530
L126:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L1660
L1280:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L767
  jmp    L543
  nopl   0x0(%rax,%rax,1)
L1676:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L543
L767:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L1676
L543:
  mov    0x8(%rsp),%eax
  cmp    %r12d,%eax
  jl     L725
  jmp    L1177
  nopl   (%rax)
L908:
  add    $0x1,%eax
  mov    %eax,0x8(%rsp)
  cmp    %r12d,%eax
  jge    L1177
L725:
  cltq
  movsbl 0x0(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  mov    0x8(%rsp),%eax
  jne    L908
L1177:
  mov    0x4(%rsp),%edx
  sub    %eax,%r12d
  sub    %ebp,%edx
  cmp    %r12d,%edx
  je     L1505
  movl   $0x0,(%r14)
  mov    $0x1,%eax
  jmp    L530
L18:
  lea    D0(%rip),%rdi
  xor    %eax,%eax
  call   <bug@plt>
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L1203
L300:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L207
  jmp    L1702
  nopl   0x0(%rax)
L579:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L1702
L207:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L579
L1702:
  mov    0x8(%rsp),%ebx
  cmp    %r12d,%ebx
  jl     L305
  jmp    L1149
  nopl   (%rax)
L425:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%ebx
  mov    %ebx,0x8(%rsp)
  cmp    %r12d,%ebx
  jge    L1149
L305:
  movslq %ebx,%rbx
  xor    %eax,%eax
  movsbl 0x0(%r13,%rbx,1),%edi
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L425
  mov    0x8(%rsp),%ebx
L1149:
  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)
  xor    %eax,%eax
  call   <fnmatch@plt>
  mov    %r15,%rdi
  test   %eax,%eax
  sete   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  call   <free@plt>
  mov    %rbp,%rdi
  call   <free@plt>
  mov    $0x1,%eax
  jmp    L530
L1660:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1280
L270:
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  sete   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L1607:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1450
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setne  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L1648:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L1385
L366:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L413
  jmp    L1692
  nopl   0x0(%rax)
L1234:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L1692
L413:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L1234
L1692:
  movslq 0x8(%rsp),%rax
  mov    %eax,%edx
  cmp    %r12d,%eax
  jl     L327
  jmp    L1467
L1393:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%edx
  mov    %edx,0x8(%rsp)
  cmp    %r12d,%edx
  jge    L1595
L327:
  movslq %edx,%rdx
  xor    %eax,%eax
  movsbl 0x0(%r13,%rdx,1),%edi
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L1393
  movslq 0x8(%rsp),%rax
L1467:
  mov    0x4(%rsp),%ebx
  sub    %eax,%r12d
  movslq %ebp,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  sub    %ebp,%ebx
  cmp    %ebx,%r12d
  mov    %ebx,%edx
  cmovle %r12d,%edx
  add    %r13,%rdi
  movslq %edx,%rdx
  call   <strncmp@plt>
  mov    %eax,%edx
  mov    $0x1,%eax
  test   %edx,%edx
  jg     L1443
  cmp    %ebx,%r12d
  setle  %cl
  xor    %eax,%eax
  test   %edx,%edx
  sete   %al
  and    %ecx,%eax
  jmp    L1443
L711:
  cltq
  movslq %ebp,%rdi
  movslq %edx,%rdx
  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    L530
L1505:
  cltq
  movslq %ebp,%rdi
  movslq %edx,%rdx
  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    L530
L1385:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L366
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setge  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L1595:
  movslq %edx,%rax
  jmp    L1467
L1203:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L300
  jmp    L270
L627:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L418
L250:
  mov    0x4(%rsp),%eax
  cmp    %eax,%ebp
  jl     L812
  jmp    L673
  xchg   %ax,%ax
L1367:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L673
L812:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L1367
L673:
  movslq 0x8(%rsp),%rax
  mov    %eax,%edx
  cmp    %r12d,%eax
  jl     L1041
  jmp    L377
L1507:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%edx
  mov    %edx,0x8(%rsp)
  cmp    %r12d,%edx
  jge    L778
L1041:
  movslq %edx,%rdx
  xor    %eax,%eax
  movsbl 0x0(%r13,%rdx,1),%edi
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L1507
  movslq 0x8(%rsp),%rax
L377:
  mov    0x4(%rsp),%ebx
  sub    %eax,%r12d
  movslq %ebp,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  sub    %ebp,%ebx
  cmp    %ebx,%r12d
  mov    %ebx,%edx
  cmovle %r12d,%edx
  add    %r13,%rdi
  movslq %edx,%rdx
  call   <strncmp@plt>
  mov    %eax,%edx
  mov    $0x1,%eax
  test   %edx,%edx
  jg     L1443
  cmp    %ebx,%r12d
  setl   %cl
  xor    %eax,%eax
  test   %edx,%edx
  sete   %al
  and    %ecx,%eax
  jmp    L1443
L778:
  movslq %edx,%rax
  jmp    L377
L259:
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D170(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  je     L619
  mov    0x4(%rsp),%edx
  cmp    %ebp,%edx
  je     L619
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  sub    0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L586:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L1111
L1583:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L477
  jmp    L517
  nopl   0x0(%rax,%rax,1)
L387:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L517
L477:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L387
L517:
  movslq 0x8(%rsp),%rax
  mov    %eax,%edx
  cmp    %r12d,%eax
  jl     L1382
  jmp    L103
  nopl   0x0(%rax,%rax,1)
L625:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%edx
  mov    %edx,0x8(%rsp)
  cmp    %r12d,%edx
  jge    L559
L1382:
  movslq %edx,%rdx
  xor    %eax,%eax
  movsbl 0x0(%r13,%rdx,1),%edi
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L625
  movslq 0x8(%rsp),%rax
L103:
  mov    0x4(%rsp),%ebx
  sub    %eax,%r12d
  movslq %ebp,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  sub    %ebp,%ebx
  cmp    %ebx,%r12d
  mov    %ebx,%edx
  cmovle %r12d,%edx
  add    %r13,%rdi
  movslq %edx,%rdx
  call   <strncmp@plt>
  mov    %eax,%edx
  mov    $0x1,%eax
  test   %edx,%edx
  js     L1443
  cmp    %ebx,%r12d
  setg   %cl
  xor    %eax,%eax
  test   %edx,%edx
  sete   %al
  and    %ecx,%eax
  jmp    L1443
L1701:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  jne    L620
L1705:
  mov    0x4(%rsp),%eax
  cmp    %ebp,%eax
  jg     L603
  jmp    L1663
  nopw   0x0(%rax,%rax,1)
L230:
  mov    0x4(%rsp),%eax
  sub    $0x1,%eax
  mov    %eax,0x4(%rsp)
  cmp    %ebp,%eax
  jle    L1663
L603:
  cltq
  movsbl -0x1(%r13,%rax,1),%edi
  xor    %eax,%eax
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L230
L1663:
  movslq 0x8(%rsp),%rax
  mov    %eax,%edx
  cmp    %r12d,%eax
  jl     L533
  jmp    L1636
L354:
  mov    0x8(%rsp),%eax
  lea    0x1(%rax),%edx
  mov    %edx,0x8(%rsp)
  cmp    %r12d,%edx
  jge    L1085
L533:
  movslq %edx,%rdx
  xor    %eax,%eax
  movsbl 0x0(%r13,%rdx,1),%edi
  call   <isWhite@plt>
  test   %eax,%eax
  jne    L354
  movslq 0x8(%rsp),%rax
L1636:
  mov    0x4(%rsp),%ebx
  sub    %eax,%r12d
  movslq %ebp,%rdi
  lea    0x0(%r13,%rax,1),%rsi
  sub    %ebp,%ebx
  cmp    %ebx,%r12d
  mov    %ebx,%edx
  cmovle %r12d,%edx
  add    %r13,%rdi
  movslq %edx,%rdx
  call   <strncmp@plt>
  mov    %eax,%r8d
  mov    $0x1,%eax
  test   %r8d,%r8d
  js     L1443
  sete   %dl
  xor    %eax,%eax
  cmp    %ebx,%r12d
  setge  %al
  and    %edx,%eax
  jmp    L1443
L620:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1705
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setle  %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L559:
  movslq %edx,%rax
  jmp    L103
L1085:
  movslq %edx,%rax
  jmp    L1636
L619:
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D184(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  je     L1521
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  imul   0x10(%rsp),%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L1111:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L1583
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setl   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L1521:
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D50(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  je     L945
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x10(%rsp),%ebx
  test   %ebx,%ebx
  je     L811
L861:
  mov    0xc(%rsp),%eax
  cltd
  idiv   %ebx
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L418:
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L250
  mov    0x10(%rsp),%eax
  cmp    %eax,0xc(%rsp)
  setg   %al
  movzbl %al,%eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L288:
  call   <__stack_chk_fail@plt>
L811:
  lea    D198(%rip),%rdi
  xor    %eax,%eax
  call   <bug@plt>
  jmp    L861
L945:
  xor    %eax,%eax
  mov    %r15,%r9
  mov    %rbx,%r8
  mov    %r12d,%edx
  lea    D195(%rip),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <SpliceInfix@plt>
  test   %eax,%eax
  jne    L1230
  movslq %ebp,%r15
  add    %r13,%r15
  movzbl (%r15),%ebx
  cmp    $0x7e,%bl
  je     L1033
  cmp    $0x21,%bl
  je     L1076
  cmp    $0x2d,%bl
  je     L340
  mov    $0x7,%edx
  lea    D29(%rip),%rsi
  mov    %r15,%rdi
  call   <strncmp@plt>
  mov    %eax,%r8d
  movslq %r12d,%rax
  test   %r8d,%r8d
  jne    L911
  cmpb   $0x29,-0x1(%r13,%rax,1)
  jne    L35
  mov    %r12d,%eax
  sub    %ebp,%eax
  sub    $0x8,%eax
  jmp    L1443
L1230:
  mov    0x4(%rsp),%edx
  lea    0xc(%rsp),%rcx
  mov    %ebp,%esi
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x8(%rsp),%esi
  lea    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0x10(%rsp),%ebx
  test   %ebx,%ebx
  je     L11
L363:
  mov    0xc(%rsp),%eax
  cltd
  idiv   %ebx
  mov    $0x1,%eax
  mov    %edx,(%r14)
  jmp    L530
L911:
  cmp    $0x28,%bl
  jne    L33
  cmpb   $0x29,-0x1(%r13,%rax,1)
  jne    L35
  lea    -0x1(%r12),%edx
  lea    0x1(%rbp),%esi
  mov    %r14,%rcx
  mov    %r13,%rdi
  call   <DoArithmEval>
  jmp    L530
L1076:
  lea    0xc(%rsp),%rcx
  lea    0x1(%rbp),%esi
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  xor    %eax,%eax
  cmpl   $0x0,0xc(%rsp)
  sete   %al
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L340:
  lea    0xc(%rsp),%rcx
  lea    0x1(%rbp),%esi
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  neg    %eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L11:
  lea    D198(%rip),%rdi
  xor    %eax,%eax
  call   <bug@plt>
  jmp    L363
L1033:
  lea    0xc(%rsp),%rcx
  lea    0x1(%rbp),%esi
  mov    %r12d,%edx
  mov    %r13,%rdi
  call   <DoArithmEval>
  test   %eax,%eax
  je     L35
  mov    0xc(%rsp),%eax
  not    %eax
  mov    %eax,(%r14)
  mov    $0x1,%eax
  jmp    L530
L33:
  add    %rax,%r13
  xor    %edx,%edx
  xor    %eax,%eax
  mov    %r15,%rdi
  movzbl 0x0(%r13),%ebx
  movb   $0x0,0x0(%r13)
  lea    0x10(%rsp),%rsi
  call   <strtol@plt>
  mov    %eax,(%r14)
  xor    %eax,%eax
  cmp    %r13,0x10(%rsp)
  mov    %bl,0x0(%r13)
  sete   %al
  jmp    L530
```

tool_calls: name: read_data
arguments: label: D32
data_type: string
name: read_data
arguments: label: D138
data_type: string
name: read_data
arguments: label: D181
data_type: string
name: read_data
arguments: label: D173
data_type: string
name: read_data
arguments: label: D58
data_type: string
name: read_data
arguments: label: D112
data_type: string
name: read_data
arguments: label: D139
data_type: string
name: read_data
arguments: label: D2
data_type: string
name: read_data
arguments: label: D199
data_type: string
name: read_data
arguments: label: D97
data_type: string
name: read_data
arguments: label: D104
data_type: string
name: read_data
arguments: label: D93
data_type: string
name: read_data
arguments: label: D66
data_type: string
name: read_data
arguments: label: D0
data_type: string
name: read_data
arguments: label: D170
data_type: string
name: read_data
arguments: label: D184
data_type: string
name: read_data
arguments: label: D50
data_type: string
name: read_data
arguments: label: D198
data_type: string
name: read_data
arguments: label: D195
data_type: string
name: read_data
arguments: label: D29
data_type: string

tool: D32: ||

tool: D138: &&

tool: D181: |

tool: D173: ^

tool: D58: &

tool: D112: !=

tool: D139: ==

tool: D2: =~

tool: D199: >=

tool: D97: >

tool: D104: <=

tool: D93: <

tool: D66: +

tool: D0: globbing support has not been compiled in

tool: D170: -

tool: D184: *

tool: D50: /

tool: D198: Division by zero in expression

tool: D195: %

tool: D29: length(

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);
}
```