int DoArithmEval(char *buf, int pos1, int pos2, int *result) {
  int spl1, spl2;
  int l;
  int result1, result2;
  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)) {
    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 - (int)strlen("length()");
    return 1;
  }
  if (strncmp(buf + pos1, "exists(", strlen("exists(")) == 0) {
    char *file;
    pos1 += (int)strlen("exists(");
    if (pos1 <= pos2 && buf[pos2] == '\0')
      pos2--;
    while ((pos1 <= pos2) && iswhite(buf[pos1]))
      pos1++;
    while ((pos1 <= pos2) && iswhite(buf[pos2]))
      pos2--;
    if (buf[pos2] != ')')
      bug("Wrong syntax in exists(\"file\")");
    else
      pos2--;
    if (buf[pos1] == '\"' || buf[pos1] == '<')
      pos1++;
    if (buf[pos2] == '\"' || buf[pos2] == '>')
      pos2--;
    if (pos1 > pos2)
      bug("Missing file name in exists(\"file\")");
    file = malloc(pos2 - pos1 + 2);
    memcpy(file, buf + pos1, pos2 - pos1 + 1);
    file[pos2 - pos1 + 1] = '\0';
    if (checkAbsOrCurrentDir(file) == 0)
      *result = 0;
    else
      *result = 1;
    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);
}


x86 assembly (clang, -O0):
<DoArithmEval>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x49(%rbp)
jge    11d3 <DoArithmEval+0x43>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    11e3 <DoArithmEval+0x53>
jmp    11f1 <DoArithmEval+0x61>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a6 <DoArithmEval+0x16>
jmp    11f6 <DoArithmEval+0x66>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x4a(%rbp)
jge    1228 <DoArithmEval+0x98>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x4a(%rbp)
mov    -0x4a(%rbp),%al
test   $0x1,%al
jne    1238 <DoArithmEval+0xa8>
jmp    1246 <DoArithmEval+0xb6>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    11f6 <DoArithmEval+0x66>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    125e <DoArithmEval+0xce>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1d91(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     12fe <DoArithmEval+0x16e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     12bf <DoArithmEval+0x12f>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    12cb <DoArithmEval+0x13b>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    $0x1,%al
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x4b(%rbp)
jne    12e4 <DoArithmEval+0x154>
cmpl   $0x0,-0x34(%rbp)
setne  %al
mov    %al,-0x4b(%rbp)
mov    -0x4b(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1cf4(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     139e <DoArithmEval+0x20e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     135f <DoArithmEval+0x1cf>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    136b <DoArithmEval+0x1db>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
xor    %eax,%eax
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x4c(%rbp)
je     1384 <DoArithmEval+0x1f4>
cmpl   $0x0,-0x34(%rbp)
setne  %al
mov    %al,-0x4c(%rbp)
mov    -0x4c(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1c52(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1423 <DoArithmEval+0x293>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     13ff <DoArithmEval+0x26f>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    140b <DoArithmEval+0x27b>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x30(%rbp),%ecx
or     -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1bd2(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     14a8 <DoArithmEval+0x318>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1484 <DoArithmEval+0x2f4>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1490 <DoArithmEval+0x300>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x30(%rbp),%ecx
xor    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1b4b(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     152d <DoArithmEval+0x39d>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1509 <DoArithmEval+0x379>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1515 <DoArithmEval+0x385>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x30(%rbp),%ecx
and    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1aca(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     16b0 <DoArithmEval+0x520>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     158e <DoArithmEval+0x3fe>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1690 <DoArithmEval+0x500>
jmp    1593 <DoArithmEval+0x403>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x4d(%rbp)
jge    15c5 <DoArithmEval+0x435>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
test   $0x1,%al
jne    15d5 <DoArithmEval+0x445>
jmp    15e3 <DoArithmEval+0x453>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1593 <DoArithmEval+0x403>
jmp    15e8 <DoArithmEval+0x458>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x4e(%rbp)
jle    1615 <DoArithmEval+0x485>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x4e(%rbp)
mov    -0x4e(%rbp),%al
test   $0x1,%al
jne    1625 <DoArithmEval+0x495>
jmp    1633 <DoArithmEval+0x4a3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15e8 <DoArithmEval+0x458>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
je     1656 <DoArithmEval+0x4c6>
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
jmp    168b <DoArithmEval+0x4fb>
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
movslq %eax,%rdx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
setne  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    16a4 <DoArithmEval+0x514>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x194a(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1833 <DoArithmEval+0x6a3>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1711 <DoArithmEval+0x581>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1813 <DoArithmEval+0x683>
jmp    1716 <DoArithmEval+0x586>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x4f(%rbp)
jge    1748 <DoArithmEval+0x5b8>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x4f(%rbp)
mov    -0x4f(%rbp),%al
test   $0x1,%al
jne    1758 <DoArithmEval+0x5c8>
jmp    1766 <DoArithmEval+0x5d6>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1716 <DoArithmEval+0x586>
jmp    176b <DoArithmEval+0x5db>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x50(%rbp)
jle    1798 <DoArithmEval+0x608>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x50(%rbp)
mov    -0x50(%rbp),%al
test   $0x1,%al
jne    17a8 <DoArithmEval+0x618>
jmp    17b6 <DoArithmEval+0x626>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    176b <DoArithmEval+0x5db>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
je     17d9 <DoArithmEval+0x649>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
jmp    180e <DoArithmEval+0x67e>
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
movslq %eax,%rdx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1827 <DoArithmEval+0x697>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x17ca(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     19e9 <DoArithmEval+0x859>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1894 <DoArithmEval+0x704>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    19c9 <DoArithmEval+0x839>
jmp    1899 <DoArithmEval+0x709>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x51(%rbp)
jge    18cb <DoArithmEval+0x73b>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    18db <DoArithmEval+0x74b>
jmp    18e9 <DoArithmEval+0x759>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1899 <DoArithmEval+0x709>
jmp    18ee <DoArithmEval+0x75e>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x52(%rbp)
jle    191b <DoArithmEval+0x78b>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
test   $0x1,%al
jne    192b <DoArithmEval+0x79b>
jmp    1939 <DoArithmEval+0x7a9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    18ee <DoArithmEval+0x75e>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    195c <DoArithmEval+0x7cc>
mov    -0x18(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
movslq -0x2c(%rbp),%rdx
call   1030 <strncmp@plt>
mov    %eax,-0x30(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x53(%rbp)
jg     19b6 <DoArithmEval+0x826>
xor    %eax,%eax
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x54(%rbp)
jne    19b0 <DoArithmEval+0x820>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setge  %al
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    19dd <DoArithmEval+0x84d>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
setge  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1617(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1b9f <DoArithmEval+0xa0f>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1a4a <DoArithmEval+0x8ba>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1b7f <DoArithmEval+0x9ef>
jmp    1a4f <DoArithmEval+0x8bf>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x55(%rbp)
jge    1a81 <DoArithmEval+0x8f1>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
test   $0x1,%al
jne    1a91 <DoArithmEval+0x901>
jmp    1a9f <DoArithmEval+0x90f>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1a4f <DoArithmEval+0x8bf>
jmp    1aa4 <DoArithmEval+0x914>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x56(%rbp)
jle    1ad1 <DoArithmEval+0x941>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x56(%rbp)
mov    -0x56(%rbp),%al
test   $0x1,%al
jne    1ae1 <DoArithmEval+0x951>
jmp    1aef <DoArithmEval+0x95f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1aa4 <DoArithmEval+0x914>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    1b12 <DoArithmEval+0x982>
mov    -0x18(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
movslq -0x2c(%rbp),%rdx
call   1030 <strncmp@plt>
mov    %eax,-0x30(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x57(%rbp)
jg     1b6c <DoArithmEval+0x9dc>
xor    %eax,%eax
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x58(%rbp)
jne    1b66 <DoArithmEval+0x9d6>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setg   %al
mov    %al,-0x58(%rbp)
mov    -0x58(%rbp),%al
mov    %al,-0x57(%rbp)
mov    -0x57(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1b93 <DoArithmEval+0xa03>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1463(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1d55 <DoArithmEval+0xbc5>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1c00 <DoArithmEval+0xa70>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1d35 <DoArithmEval+0xba5>
jmp    1c05 <DoArithmEval+0xa75>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x59(%rbp)
jge    1c37 <DoArithmEval+0xaa7>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    1c47 <DoArithmEval+0xab7>
jmp    1c55 <DoArithmEval+0xac5>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1c05 <DoArithmEval+0xa75>
jmp    1c5a <DoArithmEval+0xaca>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x5a(%rbp)
jle    1c87 <DoArithmEval+0xaf7>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x5a(%rbp)
mov    -0x5a(%rbp),%al
test   $0x1,%al
jne    1c97 <DoArithmEval+0xb07>
jmp    1ca5 <DoArithmEval+0xb15>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1c5a <DoArithmEval+0xaca>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    1cc8 <DoArithmEval+0xb38>
mov    -0x18(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
movslq -0x2c(%rbp),%rdx
call   1030 <strncmp@plt>
mov    %eax,-0x30(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x5b(%rbp)
jl     1d22 <DoArithmEval+0xb92>
xor    %eax,%eax
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x5c(%rbp)
jne    1d1c <DoArithmEval+0xb8c>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setle  %al
mov    %al,-0x5c(%rbp)
mov    -0x5c(%rbp),%al
mov    %al,-0x5b(%rbp)
mov    -0x5b(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1d49 <DoArithmEval+0xbb9>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x12b0(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1f0b <DoArithmEval+0xd7b>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1db6 <DoArithmEval+0xc26>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1eeb <DoArithmEval+0xd5b>
jmp    1dbb <DoArithmEval+0xc2b>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x5d(%rbp)
jge    1ded <DoArithmEval+0xc5d>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x5d(%rbp)
mov    -0x5d(%rbp),%al
test   $0x1,%al
jne    1dfd <DoArithmEval+0xc6d>
jmp    1e0b <DoArithmEval+0xc7b>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1dbb <DoArithmEval+0xc2b>
jmp    1e10 <DoArithmEval+0xc80>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x5e(%rbp)
jle    1e3d <DoArithmEval+0xcad>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x5e(%rbp)
mov    -0x5e(%rbp),%al
test   $0x1,%al
jne    1e4d <DoArithmEval+0xcbd>
jmp    1e5b <DoArithmEval+0xccb>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1e10 <DoArithmEval+0xc80>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    1e7e <DoArithmEval+0xcee>
mov    -0x18(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
movslq -0x2c(%rbp),%rdx
call   1030 <strncmp@plt>
mov    %eax,-0x30(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x5f(%rbp)
jl     1ed8 <DoArithmEval+0xd48>
xor    %eax,%eax
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x60(%rbp)
jne    1ed2 <DoArithmEval+0xd42>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x60(%rbp)
mov    -0x60(%rbp),%al
mov    %al,-0x5f(%rbp)
mov    -0x5f(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1eff <DoArithmEval+0xd6f>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x10fc(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1f90 <DoArithmEval+0xe00>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1f6c <DoArithmEval+0xddc>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1f78 <DoArithmEval+0xde8>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1079(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     2026 <DoArithmEval+0xe96>
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     2021 <DoArithmEval+0xe91>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1ffd <DoArithmEval+0xe6d>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2009 <DoArithmEval+0xe79>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x30(%rbp),%ecx
sub    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
jmp    2026 <DoArithmEval+0xe96>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xfe5(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     20ac <DoArithmEval+0xf1c>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     2087 <DoArithmEval+0xef7>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2093 <DoArithmEval+0xf03>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x30(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xf61(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     214c <DoArithmEval+0xfbc>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     210d <DoArithmEval+0xf7d>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2119 <DoArithmEval+0xf89>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
cmpl   $0x0,-0x34(%rbp)
jne    2131 <DoArithmEval+0xfa1>
lea    0xef6(%rip),%rdi
mov    $0x0,%al
call   1040 <bug@plt>
mov    -0x30(%rbp),%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xee2(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10b0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     21ea <DoArithmEval+0x105a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     21ad <DoArithmEval+0x101d>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x34(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    21b9 <DoArithmEval+0x1029>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
cmpl   $0x0,-0x34(%rbp)
jne    21d1 <DoArithmEval+0x1041>
lea    0xe56(%rip),%rdi
mov    $0x0,%al
call   1040 <bug@plt>
mov    -0x30(%rbp),%eax
cltd
idivl  -0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    %edx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7e,%eax
jne    2242 <DoArithmEval+0x10b2>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    222a <DoArithmEval+0x109a>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x30(%rbp),%ecx
xor    $0xffffffff,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x21,%eax
jne    22a2 <DoArithmEval+0x1112>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2282 <DoArithmEval+0x10f2>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
cmpl   $0x0,-0x30(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    22f9 <DoArithmEval+0x1169>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    22e2 <DoArithmEval+0x1152>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
xor    %ecx,%ecx
sub    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
lea    0xd36(%rip),%rsi
mov    $0x7,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    235f <DoArithmEval+0x11cf>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     2344 <DoArithmEval+0x11b4>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x18(%rbp),%ecx
sub    -0x14(%rbp),%ecx
sub    $0x8,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
lea    0xcd8(%rip),%rsi
mov    $0x7,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    258a <DoArithmEval+0x13fa>
mov    -0x14(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     23b7 <DoArithmEval+0x1227>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    23b7 <DoArithmEval+0x1227>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    23bc <DoArithmEval+0x122c>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x61(%rbp)
jg     23e9 <DoArithmEval+0x1259>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    23f9 <DoArithmEval+0x1269>
jmp    2407 <DoArithmEval+0x1277>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    23bc <DoArithmEval+0x122c>
jmp    240c <DoArithmEval+0x127c>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x62(%rbp)
jg     2439 <DoArithmEval+0x12a9>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1090 <iswhite@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
test   $0x1,%al
jne    2449 <DoArithmEval+0x12b9>
jmp    2457 <DoArithmEval+0x12c7>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    240c <DoArithmEval+0x127c>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     247f <DoArithmEval+0x12ef>
lea    0xbde(%rip),%rdi
mov    $0x0,%al
call   1040 <bug@plt>
jmp    2488 <DoArithmEval+0x12f8>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x22,%eax
je     24b2 <DoArithmEval+0x1322>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3c,%eax
jne    24bb <DoArithmEval+0x132b>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x22,%eax
je     24e5 <DoArithmEval+0x1355>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3e,%eax
jne    24ee <DoArithmEval+0x135e>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    2508 <DoArithmEval+0x1378>
lea    0xb6f(%rip),%rdi
mov    $0x0,%al
call   1040 <bug@plt>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdx
call   1080 <memcpy@plt>
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x48(%rbp),%rdi
mov    $0x0,%al
call   1050 <checkAbsOrCurrentDir@plt>
cmp    $0x0,%eax
jne    2574 <DoArithmEval+0x13e4>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
jmp    257e <DoArithmEval+0x13ee>
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    25e6 <DoArithmEval+0x1456>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     25c5 <DoArithmEval+0x1435>
movl   $0x0,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
mov    -0x20(%rbp),%rcx
call   1060 <DoArithmEval@plt>
mov    %eax,-0x4(%rbp)
jmp    2649 <DoArithmEval+0x14b9>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x35(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
lea    -0x40(%rbp),%rsi
xor    %edx,%edx
call   1070 <strtol@plt>
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x35(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DoArithmEval>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r14
mov    %edx,%ebx
mov    %esi,%r12d
mov    %rdi,%r15
cmp    %edx,%esi
mov    %rcx,0x20(%rsp)
jge    11df <DoArithmEval+0x4f>
movslq %r12d,%rbp
add    %r15,%rbp
nopl   0x0(%rax,%rax,1)
movsbl 0x0(%rbp),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     11df <DoArithmEval+0x4f>
add    $0x1,%r12d
add    $0x1,%rbp
cmp    %r12d,%ebx
jne    11c0 <DoArithmEval+0x30>
mov    %ebx,%r12d
movslq %ebx,%rbp
movslq %r12d,%r13
cmp    %ebx,%r13d
mov    %ebx,%r14d
cmovl  %r12d,%r14d
add    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r13,%rbp
jle    121f <DoArithmEval+0x8f>
movsbl -0x1(%r15,%rbp,1),%edi
add    $0xffffffffffffffff,%rbp
xor    %eax,%eax
call   1090 <iswhite@plt>
add    $0xffffffff,%ebx
test   %eax,%eax
jne    1200 <DoArithmEval+0x70>
jmp    1222 <DoArithmEval+0x92>
mov    %r14d,%ebx
xor    %ebp,%ebp
mov    %ebx,%r14d
sub    %r12d,%r14d
je     1453 <DoArithmEval+0x2c3>
lea    0xdc9(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     12a6 <DoArithmEval+0x116>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x10(%rsp),%eax
xor    %ecx,%ecx
or     0xc(%rsp),%eax
setne  %cl
mov    0x20(%rsp),%rax
mov    %ecx,(%rax)
jmp    144e <DoArithmEval+0x2be>
lea    0xd56(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     131d <DoArithmEval+0x18d>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
cmpl   $0x0,0x10(%rsp)
setne  %al
cmpl   $0x0,0xc(%rsp)
setne  %cl
and    %al,%cl
movzbl %cl,%eax
jmp    1447 <DoArithmEval+0x2b7>
lea    0xcdd(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1387 <DoArithmEval+0x1f7>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0xc(%rsp),%eax
or     0x10(%rsp),%eax
jmp    1447 <DoArithmEval+0x2b7>
lea    0xc78(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     13ea <DoArithmEval+0x25a>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0xc(%rsp),%eax
xor    0x10(%rsp),%eax
jmp    1447 <DoArithmEval+0x2b7>
lea    0xc13(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1464 <DoArithmEval+0x2d4>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0xc(%rsp),%eax
and    0x10(%rsp),%eax
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
mov    $0x1,%ebp
mov    %ebp,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xb9d(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     154c <DoArithmEval+0x3bc>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     14ca <DoArithmEval+0x33a>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     14ca <DoArithmEval+0x33a>
mov    0x10(%rsp),%eax
xor    %ecx,%ecx
cmp    0xc(%rsp),%eax
jmp    1297 <DoArithmEval+0x107>
mov    0x4(%rsp),%eax
cmp    %eax,%r12d
jge    14f6 <DoArithmEval+0x366>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     14f6 <DoArithmEval+0x366>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r12d
jl     14d3 <DoArithmEval+0x343>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebx
jle    1520 <DoArithmEval+0x390>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1520 <DoArithmEval+0x390>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebx
jg     14fe <DoArithmEval+0x36e>
movslq 0x4(%rsp),%rdx
sub    %r13,%rdx
sub    %ecx,%ebx
cmp    %ebx,%edx
jne    15b5 <DoArithmEval+0x425>
add    %r15,%r13
movslq %ecx,%rsi
add    %r15,%rsi
mov    %r13,%rdi
call   1030 <strncmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
jmp    1297 <DoArithmEval+0x107>
lea    0xab8(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     164a <DoArithmEval+0x4ba>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     15c5 <DoArithmEval+0x435>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     15c5 <DoArithmEval+0x435>
mov    0x10(%rsp),%eax
xor    %ecx,%ecx
cmp    0xc(%rsp),%eax
sete   %cl
jmp    129a <DoArithmEval+0x10a>
mov    0x20(%rsp),%rax
movl   $0x1,(%rax)
jmp    144e <DoArithmEval+0x2be>
mov    0x4(%rsp),%eax
cmp    %eax,%r12d
jge    15f1 <DoArithmEval+0x461>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     15f1 <DoArithmEval+0x461>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r12d
jl     15ce <DoArithmEval+0x43e>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebx
jle    161b <DoArithmEval+0x48b>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     161b <DoArithmEval+0x48b>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebx
jg     15f9 <DoArithmEval+0x469>
movslq 0x4(%rsp),%rdx
sub    %r13,%rdx
sub    %ecx,%ebx
cmp    %ebx,%edx
jne    16b1 <DoArithmEval+0x521>
add    %r15,%r13
movslq %ecx,%rsi
add    %r15,%rsi
mov    %r13,%rdi
call   1030 <strncmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
sete   %cl
jmp    129a <DoArithmEval+0x10a>
lea    0x9bd(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1756 <DoArithmEval+0x5c6>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     16c1 <DoArithmEval+0x531>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     16c1 <DoArithmEval+0x531>
mov    0x10(%rsp),%eax
cmp    0xc(%rsp),%eax
setge  %cl
jmp    1315 <DoArithmEval+0x185>
mov    0x20(%rsp),%rax
movl   $0x0,(%rax)
jmp    144e <DoArithmEval+0x2be>
mov    0x4(%rsp),%eax
cmp    %eax,%r12d
jge    16ed <DoArithmEval+0x55d>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     16ed <DoArithmEval+0x55d>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r12d
jl     16ca <DoArithmEval+0x53a>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebx
jle    1717 <DoArithmEval+0x587>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1717 <DoArithmEval+0x587>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebx
jg     16f5 <DoArithmEval+0x565>
mov    0x4(%rsp),%ebp
sub    %r12d,%ebp
sub    %ecx,%ebx
cmp    %ebx,%ebp
mov    %ebp,%eax
cmovg  %ebx,%eax
add    %r15,%r13
movslq %ecx,%rsi
add    %r15,%rsi
movslq %eax,%rdx
mov    %r13,%rdi
call   1030 <strncmp@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%cl
test   %eax,%eax
jg     1315 <DoArithmEval+0x185>
sete   %al
cmp    %ebx,%ebp
setge  %cl
jmp    1313 <DoArithmEval+0x183>
lea    0x8b4(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1856 <DoArithmEval+0x6c6>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     17bd <DoArithmEval+0x62d>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     17bd <DoArithmEval+0x62d>
mov    0x10(%rsp),%eax
cmp    0xc(%rsp),%eax
setg   %cl
jmp    1315 <DoArithmEval+0x185>
mov    0x4(%rsp),%eax
cmp    %eax,%r12d
jge    17e9 <DoArithmEval+0x659>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     17e9 <DoArithmEval+0x659>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r12d
jl     17c6 <DoArithmEval+0x636>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebx
jle    1813 <DoArithmEval+0x683>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1813 <DoArithmEval+0x683>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebx
jg     17f1 <DoArithmEval+0x661>
mov    0x4(%rsp),%ebp
sub    %r12d,%ebp
sub    %ecx,%ebx
cmp    %ebx,%ebp
mov    %ebp,%eax
cmovg  %ebx,%eax
add    %r15,%r13
movslq %ecx,%rsi
add    %r15,%rsi
movslq %eax,%rdx
mov    %r13,%rdi
call   1030 <strncmp@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%cl
test   %eax,%eax
jg     1315 <DoArithmEval+0x185>
cmp    %ebx,%ebp
setg   %dl
test   %eax,%eax
sete   %cl
and    %dl,%cl
jmp    1315 <DoArithmEval+0x185>
lea    0x7b6(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1952 <DoArithmEval+0x7c2>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     18bd <DoArithmEval+0x72d>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     18bd <DoArithmEval+0x72d>
mov    0x10(%rsp),%eax
cmp    0xc(%rsp),%eax
setle  %cl
jmp    1315 <DoArithmEval+0x185>
mov    0x4(%rsp),%eax
cmp    %eax,%r12d
jge    18e9 <DoArithmEval+0x759>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     18e9 <DoArithmEval+0x759>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r12d
jl     18c6 <DoArithmEval+0x736>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebx
jle    1913 <DoArithmEval+0x783>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1913 <DoArithmEval+0x783>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebx
jg     18f1 <DoArithmEval+0x761>
mov    0x4(%rsp),%ebp
sub    %r12d,%ebp
sub    %ecx,%ebx
cmp    %ebx,%ebp
mov    %ebp,%eax
cmovg  %ebx,%eax
add    %r15,%r13
movslq %ecx,%rsi
add    %r15,%rsi
movslq %eax,%rdx
mov    %r13,%rdi
call   1030 <strncmp@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%cl
test   %eax,%eax
js     1315 <DoArithmEval+0x185>
sete   %al
cmp    %ebx,%ebp
setle  %cl
jmp    1313 <DoArithmEval+0x183>
lea    0x6bd(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1a4e <DoArithmEval+0x8be>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     19b9 <DoArithmEval+0x829>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     19b9 <DoArithmEval+0x829>
mov    0x10(%rsp),%eax
cmp    0xc(%rsp),%eax
setl   %cl
jmp    1315 <DoArithmEval+0x185>
mov    0x4(%rsp),%eax
cmp    %eax,%r12d
jge    19e5 <DoArithmEval+0x855>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     19e5 <DoArithmEval+0x855>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r12d
jl     19c2 <DoArithmEval+0x832>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebx
jle    1a0f <DoArithmEval+0x87f>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1a0f <DoArithmEval+0x87f>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebx
jg     19ed <DoArithmEval+0x85d>
mov    0x4(%rsp),%ebp
sub    %r12d,%ebp
sub    %ecx,%ebx
cmp    %ebx,%ebp
mov    %ebp,%eax
cmovg  %ebx,%eax
add    %r15,%r13
movslq %ecx,%rsi
add    %r15,%rsi
movslq %eax,%rdx
mov    %r13,%rdi
call   1030 <strncmp@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%cl
test   %eax,%eax
js     1315 <DoArithmEval+0x185>
sete   %al
cmp    %ebx,%ebp
setl   %cl
jmp    1313 <DoArithmEval+0x183>
lea    0x5c3(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1ab8 <DoArithmEval+0x928>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0xc(%rsp),%eax
add    0x10(%rsp),%eax
jmp    1447 <DoArithmEval+0x2b7>
lea    0x55b(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1ae5 <DoArithmEval+0x955>
mov    0x4(%rsp),%edx
cmp    %r12d,%edx
jne    1b54 <DoArithmEval+0x9c4>
lea    0x530(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1b96 <DoArithmEval+0xa06>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0xc(%rsp),%eax
imul   0x10(%rsp),%eax
jmp    1447 <DoArithmEval+0x2b7>
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
xor    %ebp,%ebp
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x10(%rsp),%eax
sub    0xc(%rsp),%eax
jmp    1447 <DoArithmEval+0x2b7>
lea    0x481(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1c19 <DoArithmEval+0xa89>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jne    1c0d <DoArithmEval+0xa7d>
lea    0x41e(%rip),%rdi
xor    %eax,%eax
call   1040 <bug@plt>
mov    0xc(%rsp),%ecx
mov    0x10(%rsp),%eax
cltd
idiv   %ecx
jmp    1447 <DoArithmEval+0x2b7>
lea    0x41f(%rip),%rcx
xor    %ebp,%ebp
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   10b0 <SpliceInfix@plt>
test   %eax,%eax
je     1ca3 <DoArithmEval+0xb13>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jne    1c90 <DoArithmEval+0xb00>
lea    0x39b(%rip),%rdi
xor    %eax,%eax
call   1040 <bug@plt>
mov    0xc(%rsp),%ecx
mov    0x10(%rsp),%eax
cltd
idiv   %ecx
mov    0x20(%rsp),%rax
mov    %edx,(%rax)
jmp    144e <DoArithmEval+0x2be>
mov    (%r15,%r13,1),%al
mov    %al,0x1f(%rsp)
cmp    $0x21,%al
je     1ce6 <DoArithmEval+0xb56>
cmpb   $0x2d,0x1f(%rsp)
je     1d13 <DoArithmEval+0xb83>
cmpb   $0x7e,0x1f(%rsp)
jne    1d3c <DoArithmEval+0xbac>
add    $0x1,%r12d
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
mov    0x10(%rsp),%eax
not    %eax
jmp    1447 <DoArithmEval+0x2b7>
add    $0x1,%r12d
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
xor    %eax,%eax
cmpl   $0x0,0x10(%rsp)
sete   %al
jmp    1447 <DoArithmEval+0x2b7>
add    $0x1,%r12d
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1453 <DoArithmEval+0x2c3>
xor    %eax,%eax
sub    0x10(%rsp),%eax
jmp    1447 <DoArithmEval+0x2b7>
add    %r15,%r13
lea    0x2fb(%rip),%rsi
mov    $0x7,%edx
mov    %r13,%rdi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1da8 <DoArithmEval+0xc18>
lea    0x2eb(%rip),%rsi
mov    $0x7,%edx
mov    %r13,%rdi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1dc8 <DoArithmEval+0xc38>
cmpb   $0x28,0x1f(%rsp)
jne    1e5f <DoArithmEval+0xccf>
movslq %ebx,%rdx
cmpb   $0x29,-0x1(%r15,%rdx,1)
jne    1453 <DoArithmEval+0x2c3>
add    $0xffffffffffffffff,%rdx
add    $0x1,%r12d
mov    %r15,%rdi
mov    %r12d,%esi
mov    0x20(%rsp),%rcx
call   1060 <DoArithmEval@plt>
mov    %eax,%ebp
jmp    1453 <DoArithmEval+0x2c3>
movslq %ebx,%rax
cmpb   $0x29,-0x1(%rax,%r15,1)
jne    1453 <DoArithmEval+0x2c3>
add    $0xfffffff8,%r14d
mov    0x20(%rsp),%rax
mov    %r14d,(%rax)
jmp    144e <DoArithmEval+0x2be>
add    $0x7,%r12d
cmp    %ebx,%r12d
jg     1ddc <DoArithmEval+0xc4c>
movslq %ebx,%rax
cmpb   $0x1,(%r15,%rax,1)
sbb    $0x0,%ebx
cmp    %ebx,%r12d
jg     1e1c <DoArithmEval+0xc8c>
movslq %r12d,%rbp
lea    0x1(%rbx),%r14d
add    %r15,%rbp
mov    %ebx,%r13d
neg    %r13d
movsbl 0x0(%rbp),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     1e1c <DoArithmEval+0xc8c>
add    $0x1,%rbp
lea    (%r12,%r13,1),%eax
add    $0x1,%eax
mov    %r12d,%ecx
add    $0x1,%ecx
mov    %ecx,%r12d
cmp    $0x1,%eax
jne    1df1 <DoArithmEval+0xc61>
mov    %r14d,%r12d
movslq %r12d,%r14
cmp    %ebx,%r12d
jg     1e50 <DoArithmEval+0xcc0>
movslq %ebx,%rbp
lea    -0x1(%r12),%r13d
add    $0x1,%rbp
movsbl -0x1(%r15,%rbp,1),%edi
xor    %eax,%eax
call   1090 <iswhite@plt>
test   %eax,%eax
je     1e50 <DoArithmEval+0xcc0>
add    $0xffffffff,%ebx
add    $0xffffffffffffffff,%rbp
cmp    %r14,%rbp
jg     1e30 <DoArithmEval+0xca0>
mov    %r13d,%ebx
movslq %ebx,%rax
cmpb   $0x29,(%r15,%rax,1)
jne    1e99 <DoArithmEval+0xd09>
add    $0xffffffff,%ebx
jmp    1ea7 <DoArithmEval+0xd17>
movslq %ebx,%rbx
lea    (%r15,%rbx,1),%r14
mov    (%r15,%rbx,1),%bpl
movb   $0x0,(%r15,%rbx,1)
lea    0x10(%rsp),%rsi
mov    %r13,%rdi
xor    %edx,%edx
call   1070 <strtol@plt>
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
mov    %bpl,(%r15,%rbx,1)
xor    %ebp,%ebp
cmp    %r14,0x10(%rsp)
sete   %bpl
jmp    1453 <DoArithmEval+0x2c3>
lea    0x1b1(%rip),%rdi
xor    %eax,%eax
call   1040 <bug@plt>
mov    (%r15,%r14,1),%al
cmp    $0x3c,%al
je     1eb3 <DoArithmEval+0xd23>
cmp    $0x22,%al
jne    1eb7 <DoArithmEval+0xd27>
add    $0x1,%r12d
movslq %ebx,%rax
mov    (%r15,%rax,1),%al
cmp    $0x3e,%al
je     1ec6 <DoArithmEval+0xd36>
cmp    $0x22,%al
jne    1ec9 <DoArithmEval+0xd39>
add    $0xffffffff,%ebx
sub    %r12d,%ebx
jge    1edc <DoArithmEval+0xd4c>
lea    0x19b(%rip),%rdi
xor    %eax,%eax
call   1040 <bug@plt>
lea    0x2(%rbx),%eax
movslq %eax,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rbp
movslq %r12d,%rax
add    %rax,%r15
movslq %ebx,%rbx
lea    0x1(%rbx),%rdx
mov    %rbp,%rdi
mov    %r15,%rsi
call   1080 <memcpy@plt>
movb   $0x0,0x1(%rbp,%rbx,1)
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <checkAbsOrCurrentDir@plt>
jmp    1543 <DoArithmEval+0x3b3>

LLVM IR (-O0):
@.str = [3 x i8] c"||\00"
@.str.1 = [3 x i8] c"&&\00"
@.str.2 = [2 x i8] c"|\00"
@.str.3 = [2 x i8] c"^\00"
@.str.4 = [2 x i8] c"&\00"
@.str.5 = [3 x i8] c"!=\00"
@.str.6 = [3 x i8] c"==\00"
@.str.7 = [3 x i8] c">=\00"
@.str.8 = [2 x i8] c">\00"
@.str.9 = [3 x i8] c"<=\00"
@.str.10 = [2 x i8] c"<\00"
@.str.11 = [2 x i8] c"+\00"
@.str.12 = [2 x i8] c"-\00"
@.str.13 = [2 x i8] c"*\00"
@.str.14 = [2 x i8] c"/\00"
@.str.15 = [31 x i8] c"Division by zero in expression\00"
@.str.16 = [2 x i8] c"%\00"
@.str.17 = [8 x i8] c"length(\00"
@.str.18 = [8 x i8] c"exists(\00"
@.str.19 = [31 x i8] c"Wrong syntax in exists(\22file\22)\00"
@.str.20 = [36 x i8] c"Missing file name in exists(\22file\22)\00"
define i32 @DoArithmEval(i8* %0, i32 %1, i32 %2, i32* %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8
%16 = alloca i8*
%17 = alloca i8*
store i8* %0, i8** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32* %3, i32** %9
br label %18
18: ; preds = %33, %4
%19 = load i32, i32* %7
%20 = load i32, i32* %8
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %31
22: ; preds = %18
%23 = load i8*, i8** %6
%24 = load i32, i32* %7
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %28)
%30 = icmp ne i32 %29, 0
br label %31
31: ; preds = %22, %18
%32 = phi i1 [ false, %18 ], [ %30, %22 ]
br i1 %32, label %33, label %36
33: ; preds = %31
%34 = load i32, i32* %7
%35 = add nsw i32 %34, 1
store i32 %35, i32* %7
br label %18
36: ; preds = %31
br label %37
37: ; preds = %53, %36
%38 = load i32, i32* %7
%39 = load i32, i32* %8
%40 = icmp slt i32 %38, %39
br i1 %40, label %41, label %51
41: ; preds = %37
%42 = load i8*, i8** %6
%43 = load i32, i32* %8
%44 = sub nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %42, i64 %45
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %48)
%50 = icmp ne i32 %49, 0
br label %51
51: ; preds = %41, %37
%52 = phi i1 [ false, %37 ], [ %50, %41 ]
br i1 %52, label %53, label %56
53: ; preds = %51
%54 = load i32, i32* %8
%55 = add nsw i32 %54, -1
store i32 %55, i32* %8
br label %37
56: ; preds = %51
%57 = load i32, i32* %7
%58 = load i32, i32* %8
%59 = icmp eq i32 %57, %58
br i1 %59, label %60, label %61
60: ; preds = %56
store i32 0, i32* %5
br label %1233
61: ; preds = %56
%62 = load i8*, i8** %6
%63 = load i32, i32* %7
%64 = load i32, i32* %8
%65 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %62, i32 %63, i32 %64, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %10, i32* %11)
%66 = icmp ne i32 %65, 0
br i1 %66, label %67, label %90
67: ; preds = %61
%68 = load i8*, i8** %6
%69 = load i32, i32* %7
%70 = load i32, i32* %10
%71 = call i32 @DoArithmEval(i8* %68, i32 %69, i32 %70, i32* %13)
%72 = icmp ne i32 %71, 0
br i1 %72, label %73, label %79
73: ; preds = %67
%74 = load i8*, i8** %6
%75 = load i32, i32* %11
%76 = load i32, i32* %8
%77 = call i32 @DoArithmEval(i8* %74, i32 %75, i32 %76, i32* %14)
%78 = icmp ne i32 %77, 0
br i1 %78, label %80, label %79
79: ; preds = %73, %67
store i32 0, i32* %5
br label %1233
80: ; preds = %73
%81 = load i32, i32* %13
%82 = icmp ne i32 %81, 0
br i1 %82, label %86, label %83
83: ; preds = %80
%84 = load i32, i32* %14
%85 = icmp ne i32 %84, 0
br label %86
86: ; preds = %83, %80
%87 = phi i1 [ true, %80 ], [ %85, %83 ]
%88 = zext i1 %87 to i32
%89 = load i32*, i32** %9
store i32 %88, i32* %89
store i32 1, i32* %5
br label %1233
90: ; preds = %61
%91 = load i8*, i8** %6
%92 = load i32, i32* %7
%93 = load i32, i32* %8
%94 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %91, i32 %92, i32 %93, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %10, i32* %11)
%95 = icmp ne i32 %94, 0
br i1 %95, label %96, label %119
96: ; preds = %90
%97 = load i8*, i8** %6
%98 = load i32, i32* %7
%99 = load i32, i32* %10
%100 = call i32 @DoArithmEval(i8* %97, i32 %98, i32 %99, i32* %13)
%101 = icmp ne i32 %100, 0
br i1 %101, label %102, label %108
102: ; preds = %96
%103 = load i8*, i8** %6
%104 = load i32, i32* %11
%105 = load i32, i32* %8
%106 = call i32 @DoArithmEval(i8* %103, i32 %104, i32 %105, i32* %14)
%107 = icmp ne i32 %106, 0
br i1 %107, label %109, label %108
108: ; preds = %102, %96
store i32 0, i32* %5
br label %1233
109: ; preds = %102
%110 = load i32, i32* %13
%111 = icmp ne i32 %110, 0
br i1 %111, label %112, label %115
112: ; preds = %109
%113 = load i32, i32* %14
%114 = icmp ne i32 %113, 0
br label %115
115: ; preds = %112, %109
%116 = phi i1 [ false, %109 ], [ %114, %112 ]
%117 = zext i1 %116 to i32
%118 = load i32*, i32** %9
store i32 %117, i32* %118
store i32 1, i32* %5
br label %1233
119: ; preds = %90
%120 = load i8*, i8** %6
%121 = load i32, i32* %7
%122 = load i32, i32* %8
%123 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %120, i32 %121, i32 %122, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32* %10, i32* %11)
%124 = icmp ne i32 %123, 0
br i1 %124, label %125, label %143
125: ; preds = %119
%126 = load i8*, i8** %6
%127 = load i32, i32* %7
%128 = load i32, i32* %10
%129 = call i32 @DoArithmEval(i8* %126, i32 %127, i32 %128, i32* %13)
%130 = icmp ne i32 %129, 0
br i1 %130, label %131, label %137
131: ; preds = %125
%132 = load i8*, i8** %6
%133 = load i32, i32* %11
%134 = load i32, i32* %8
%135 = call i32 @DoArithmEval(i8* %132, i32 %133, i32 %134, i32* %14)
%136 = icmp ne i32 %135, 0
br i1 %136, label %138, label %137
137: ; preds = %131, %125
store i32 0, i32* %5
br label %1233
138: ; preds = %131
%139 = load i32, i32* %13
%140 = load i32, i32* %14
%141 = or i32 %139, %140
%142 = load i32*, i32** %9
store i32 %141, i32* %142
store i32 1, i32* %5
br label %1233
143: ; preds = %119
%144 = load i8*, i8** %6
%145 = load i32, i32* %7
%146 = load i32, i32* %8
%147 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %144, i32 %145, i32 %146, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), i32* %10, i32* %11)
%148 = icmp ne i32 %147, 0
br i1 %148, label %149, label %167
149: ; preds = %143
%150 = load i8*, i8** %6
%151 = load i32, i32* %7
%152 = load i32, i32* %10
%153 = call i32 @DoArithmEval(i8* %150, i32 %151, i32 %152, i32* %13)
%154 = icmp ne i32 %153, 0
br i1 %154, label %155, label %161
155: ; preds = %149
%156 = load i8*, i8** %6
%157 = load i32, i32* %11
%158 = load i32, i32* %8
%159 = call i32 @DoArithmEval(i8* %156, i32 %157, i32 %158, i32* %14)
%160 = icmp ne i32 %159, 0
br i1 %160, label %162, label %161
161: ; preds = %155, %149
store i32 0, i32* %5
br label %1233
162: ; preds = %155
%163 = load i32, i32* %13
%164 = load i32, i32* %14
%165 = xor i32 %163, %164
%166 = load i32*, i32** %9
store i32 %165, i32* %166
store i32 1, i32* %5
br label %1233
167: ; preds = %143
%168 = load i8*, i8** %6
%169 = load i32, i32* %7
%170 = load i32, i32* %8
%171 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %168, i32 %169, i32 %170, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i32* %10, i32* %11)
%172 = icmp ne i32 %171, 0
br i1 %172, label %173, label %191
173: ; preds = %167
%174 = load i8*, i8** %6
%175 = load i32, i32* %7
%176 = load i32, i32* %10
%177 = call i32 @DoArithmEval(i8* %174, i32 %175, i32 %176, i32* %13)
%178 = icmp ne i32 %177, 0
br i1 %178, label %179, label %185
179: ; preds = %173
%180 = load i8*, i8** %6
%181 = load i32, i32* %11
%182 = load i32, i32* %8
%183 = call i32 @DoArithmEval(i8* %180, i32 %181, i32 %182, i32* %14)
%184 = icmp ne i32 %183, 0
br i1 %184, label %186, label %185
185: ; preds = %179, %173
store i32 0, i32* %5
br label %1233
186: ; preds = %179
%187 = load i32, i32* %13
%188 = load i32, i32* %14
%189 = and i32 %187, %188
%190 = load i32*, i32** %9
store i32 %189, i32* %190
store i32 1, i32* %5
br label %1233
191: ; preds = %167
%192 = load i8*, i8** %6
%193 = load i32, i32* %7
%194 = load i32, i32* %8
%195 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %192, i32 %193, i32 %194, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32* %10, i32* %11)
%196 = icmp ne i32 %195, 0
br i1 %196, label %197, label %283
197: ; preds = %191
%198 = load i8*, i8** %6
%199 = load i32, i32* %7
%200 = load i32, i32* %10
%201 = call i32 @DoArithmEval(i8* %198, i32 %199, i32 %200, i32* %13)
%202 = icmp ne i32 %201, 0
br i1 %202, label %203, label %209
203: ; preds = %197
%204 = load i8*, i8** %6
%205 = load i32, i32* %11
%206 = load i32, i32* %8
%207 = call i32 @DoArithmEval(i8* %204, i32 %205, i32 %206, i32* %14)
%208 = icmp ne i32 %207, 0
br i1 %208, label %276, label %209
209: ; preds = %203, %197
br label %210
210: ; preds = %226, %209
%211 = load i32, i32* %7
%212 = load i32, i32* %10
%213 = icmp slt i32 %211, %212
br i1 %213, label %214, label %224
214: ; preds = %210
%215 = load i8*, i8** %6
%216 = load i32, i32* %10
%217 = sub nsw i32 %216, 1
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i8, i8* %215, i64 %218
%220 = load i8, i8* %219
%221 = sext i8 %220 to i32
%222 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %221)
%223 = icmp ne i32 %222, 0
br label %224
224: ; preds = %214, %210
%225 = phi i1 [ false, %210 ], [ %223, %214 ]
br i1 %225, label %226, label %229
226: ; preds = %224
%227 = load i32, i32* %10
%228 = add nsw i32 %227, -1
store i32 %228, i32* %10
br label %210
229: ; preds = %224
br label %230
230: ; preds = %245, %229
%231 = load i32, i32* %8
%232 = load i32, i32* %11
%233 = icmp sgt i32 %231, %232
br i1 %233, label %234, label %243
234: ; preds = %230
%235 = load i8*, i8** %6
%236 = load i32, i32* %11
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i8, i8* %235, i64 %237
%239 = load i8, i8* %238
%240 = sext i8 %239 to i32
%241 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %240)
%242 = icmp ne i32 %241, 0
br label %243
243: ; preds = %234, %230
%244 = phi i1 [ false, %230 ], [ %242, %234 ]
br i1 %244, label %245, label %248
245: ; preds = %243
%246 = load i32, i32* %11
%247 = add nsw i32 %246, 1
store i32 %247, i32* %11
br label %230
248: ; preds = %243
%249 = load i32, i32* %10
%250 = load i32, i32* %7
%251 = sub nsw i32 %249, %250
%252 = load i32, i32* %8
%253 = load i32, i32* %11
%254 = sub nsw i32 %252, %253
%255 = icmp ne i32 %251, %254
br i1 %255, label %256, label %258
256: ; preds = %248
%257 = load i32*, i32** %9
store i32 1, i32* %257
br label %275
258: ; preds = %248
%259 = load i8*, i8** %6
%260 = load i32, i32* %7
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i8, i8* %259, i64 %261
%263 = load i8*, i8** %6
%264 = load i32, i32* %11
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i8, i8* %263, i64 %265
%267 = load i32, i32* %10
%268 = load i32, i32* %7
%269 = sub nsw i32 %267, %268
%270 = sext i32 %269 to i64
%271 = call i32 @strncmp(i8* %262, i8* %266, i64 %270)
%272 = icmp ne i32 %271, 0
%273 = zext i1 %272 to i32
%274 = load i32*, i32** %9
store i32 %273, i32* %274
br label %275
275: ; preds = %258, %256
br label %282
276: ; preds = %203
%277 = load i32, i32* %13
%278 = load i32, i32* %14
%279 = icmp ne i32 %277, %278
%280 = zext i1 %279 to i32
%281 = load i32*, i32** %9
store i32 %280, i32* %281
br label %282
282: ; preds = %276, %275
store i32 1, i32* %5
br label %1233
283: ; preds = %191
%284 = load i8*, i8** %6
%285 = load i32, i32* %7
%286 = load i32, i32* %8
%287 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %284, i32 %285, i32 %286, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), i32* %10, i32* %11)
%288 = icmp ne i32 %287, 0
br i1 %288, label %289, label %375
289: ; preds = %283
%290 = load i8*, i8** %6
%291 = load i32, i32* %7
%292 = load i32, i32* %10
%293 = call i32 @DoArithmEval(i8* %290, i32 %291, i32 %292, i32* %13)
%294 = icmp ne i32 %293, 0
br i1 %294, label %295, label %301
295: ; preds = %289
%296 = load i8*, i8** %6
%297 = load i32, i32* %11
%298 = load i32, i32* %8
%299 = call i32 @DoArithmEval(i8* %296, i32 %297, i32 %298, i32* %14)
%300 = icmp ne i32 %299, 0
br i1 %300, label %368, label %301
301: ; preds = %295, %289
br label %302
302: ; preds = %318, %301
%303 = load i32, i32* %7
%304 = load i32, i32* %10
%305 = icmp slt i32 %303, %304
br i1 %305, label %306, label %316
306: ; preds = %302
%307 = load i8*, i8** %6
%308 = load i32, i32* %10
%309 = sub nsw i32 %308, 1
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i8, i8* %307, i64 %310
%312 = load i8, i8* %311
%313 = sext i8 %312 to i32
%314 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %313)
%315 = icmp ne i32 %314, 0
br label %316
316: ; preds = %306, %302
%317 = phi i1 [ false, %302 ], [ %315, %306 ]
br i1 %317, label %318, label %321
318: ; preds = %316
%319 = load i32, i32* %10
%320 = add nsw i32 %319, -1
store i32 %320, i32* %10
br label %302
321: ; preds = %316
br label %322
322: ; preds = %337, %321
%323 = load i32, i32* %8
%324 = load i32, i32* %11
%325 = icmp sgt i32 %323, %324
br i1 %325, label %326, label %335
326: ; preds = %322
%327 = load i8*, i8** %6
%328 = load i32, i32* %11
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i8, i8* %327, i64 %329
%331 = load i8, i8* %330
%332 = sext i8 %331 to i32
%333 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %332)
%334 = icmp ne i32 %333, 0
br label %335
335: ; preds = %326, %322
%336 = phi i1 [ false, %322 ], [ %334, %326 ]
br i1 %336, label %337, label %340
337: ; preds = %335
%338 = load i32, i32* %11
%339 = add nsw i32 %338, 1
store i32 %339, i32* %11
br label %322
340: ; preds = %335
%341 = load i32, i32* %10
%342 = load i32, i32* %7
%343 = sub nsw i32 %341, %342
%344 = load i32, i32* %8
%345 = load i32, i32* %11
%346 = sub nsw i32 %344, %345
%347 = icmp ne i32 %343, %346
br i1 %347, label %348, label %350
348: ; preds = %340
%349 = load i32*, i32** %9
store i32 0, i32* %349
br label %367
350: ; preds = %340
%351 = load i8*, i8** %6
%352 = load i32, i32* %7
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds i8, i8* %351, i64 %353
%355 = load i8*, i8** %6
%356 = load i32, i32* %11
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i8, i8* %355, i64 %357
%359 = load i32, i32* %10
%360 = load i32, i32* %7
%361 = sub nsw i32 %359, %360
%362 = sext i32 %361 to i64
%363 = call i32 @strncmp(i8* %354, i8* %358, i64 %362)
%364 = icmp eq i32 %363, 0
%365 = zext i1 %364 to i32
%366 = load i32*, i32** %9
store i32 %365, i32* %366
br label %367
367: ; preds = %350, %348
br label %374
368: ; preds = %295
%369 = load i32, i32* %13
%370 = load i32, i32* %14
%371 = icmp eq i32 %369, %370
%372 = zext i1 %371 to i32
%373 = load i32*, i32** %9
store i32 %372, i32* %373
br label %374
374: ; preds = %368, %367
store i32 1, i32* %5
br label %1233
375: ; preds = %283
%376 = load i8*, i8** %6
%377 = load i32, i32* %7
%378 = load i32, i32* %8
%379 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %376, i32 %377, i32 %378, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32* %10, i32* %11)
%380 = icmp ne i32 %379, 0
br i1 %380, label %381, label %483
381: ; preds = %375
%382 = load i8*, i8** %6
%383 = load i32, i32* %7
%384 = load i32, i32* %10
%385 = call i32 @DoArithmEval(i8* %382, i32 %383, i32 %384, i32* %13)
%386 = icmp ne i32 %385, 0
br i1 %386, label %387, label %393
387: ; preds = %381
%388 = load i8*, i8** %6
%389 = load i32, i32* %11
%390 = load i32, i32* %8
%391 = call i32 @DoArithmEval(i8* %388, i32 %389, i32 %390, i32* %14)
%392 = icmp ne i32 %391, 0
br i1 %392, label %476, label %393
393: ; preds = %387, %381
br label %394
394: ; preds = %410, %393
%395 = load i32, i32* %7
%396 = load i32, i32* %10
%397 = icmp slt i32 %395, %396
br i1 %397, label %398, label %408
398: ; preds = %394
%399 = load i8*, i8** %6
%400 = load i32, i32* %10
%401 = sub nsw i32 %400, 1
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds i8, i8* %399, i64 %402
%404 = load i8, i8* %403
%405 = sext i8 %404 to i32
%406 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %405)
%407 = icmp ne i32 %406, 0
br label %408
408: ; preds = %398, %394
%409 = phi i1 [ false, %394 ], [ %407, %398 ]
br i1 %409, label %410, label %413
410: ; preds = %408
%411 = load i32, i32* %10
%412 = add nsw i32 %411, -1
store i32 %412, i32* %10
br label %394
413: ; preds = %408
br label %414
414: ; preds = %429, %413
%415 = load i32, i32* %8
%416 = load i32, i32* %11
%417 = icmp sgt i32 %415, %416
br i1 %417, label %418, label %427
418: ; preds = %414
%419 = load i8*, i8** %6
%420 = load i32, i32* %11
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds i8, i8* %419, i64 %421
%423 = load i8, i8* %422
%424 = sext i8 %423 to i32
%425 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %424)
%426 = icmp ne i32 %425, 0
br label %427
427: ; preds = %418, %414
%428 = phi i1 [ false, %414 ], [ %426, %418 ]
br i1 %428, label %429, label %432
429: ; preds = %427
%430 = load i32, i32* %11
%431 = add nsw i32 %430, 1
store i32 %431, i32* %11
br label %414
432: ; preds = %427
%433 = load i32, i32* %10
%434 = load i32, i32* %7
%435 = sub nsw i32 %433, %434
store i32 %435, i32* %12
%436 = load i32, i32* %12
%437 = load i32, i32* %8
%438 = load i32, i32* %11
%439 = sub nsw i32 %437, %438
%440 = icmp sgt i32 %436, %439
br i1 %440, label %441, label %445
441: ; preds = %432
%442 = load i32, i32* %8
%443 = load i32, i32* %11
%444 = sub nsw i32 %442, %443
store i32 %444, i32* %12
br label %445
445: ; preds = %441, %432
%446 = load i8*, i8** %6
%447 = load i32, i32* %7
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds i8, i8* %446, i64 %448
%450 = load i8*, i8** %6
%451 = load i32, i32* %11
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds i8, i8* %450, i64 %452
%454 = load i32, i32* %12
%455 = sext i32 %454 to i64
%456 = call i32 @strncmp(i8* %449, i8* %453, i64 %455)
store i32 %456, i32* %13
%457 = load i32, i32* %13
%458 = icmp sgt i32 %457, 0
br i1 %458, label %472, label %459
459: ; preds = %445
%460 = load i32, i32* %13
%461 = icmp eq i32 %460, 0
br i1 %461, label %462, label %470
462: ; preds = %459
%463 = load i32, i32* %10
%464 = load i32, i32* %7
%465 = sub nsw i32 %463, %464
%466 = load i32, i32* %8
%467 = load i32, i32* %11
%468 = sub nsw i32 %466, %467
%469 = icmp sge i32 %465, %468
br label %470
470: ; preds = %462, %459
%471 = phi i1 [ false, %459 ], [ %469, %462 ]
br label %472
472: ; preds = %470, %445
%473 = phi i1 [ true, %445 ], [ %471, %470 ]
%474 = zext i1 %473 to i32
%475 = load i32*, i32** %9
store i32 %474, i32* %475
br label %482
476: ; preds = %387
%477 = load i32, i32* %13
%478 = load i32, i32* %14
%479 = icmp sge i32 %477, %478
%480 = zext i1 %479 to i32
%481 = load i32*, i32** %9
store i32 %480, i32* %481
br label %482
482: ; preds = %476, %472
store i32 1, i32* %5
br label %1233
483: ; preds = %375
%484 = load i8*, i8** %6
%485 = load i32, i32* %7
%486 = load i32, i32* %8
%487 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %484, i32 %485, i32 %486, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), i32* %10, i32* %11)
%488 = icmp ne i32 %487, 0
br i1 %488, label %489, label %591
489: ; preds = %483
%490 = load i8*, i8** %6
%491 = load i32, i32* %7
%492 = load i32, i32* %10
%493 = call i32 @DoArithmEval(i8* %490, i32 %491, i32 %492, i32* %13)
%494 = icmp ne i32 %493, 0
br i1 %494, label %495, label %501
495: ; preds = %489
%496 = load i8*, i8** %6
%497 = load i32, i32* %11
%498 = load i32, i32* %8
%499 = call i32 @DoArithmEval(i8* %496, i32 %497, i32 %498, i32* %14)
%500 = icmp ne i32 %499, 0
br i1 %500, label %584, label %501
501: ; preds = %495, %489
br label %502
502: ; preds = %518, %501
%503 = load i32, i32* %7
%504 = load i32, i32* %10
%505 = icmp slt i32 %503, %504
br i1 %505, label %506, label %516
506: ; preds = %502
%507 = load i8*, i8** %6
%508 = load i32, i32* %10
%509 = sub nsw i32 %508, 1
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds i8, i8* %507, i64 %510
%512 = load i8, i8* %511
%513 = sext i8 %512 to i32
%514 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %513)
%515 = icmp ne i32 %514, 0
br label %516
516: ; preds = %506, %502
%517 = phi i1 [ false, %502 ], [ %515, %506 ]
br i1 %517, label %518, label %521
518: ; preds = %516
%519 = load i32, i32* %10
%520 = add nsw i32 %519, -1
store i32 %520, i32* %10
br label %502
521: ; preds = %516
br label %522
522: ; preds = %537, %521
%523 = load i32, i32* %8
%524 = load i32, i32* %11
%525 = icmp sgt i32 %523, %524
br i1 %525, label %526, label %535
526: ; preds = %522
%527 = load i8*, i8** %6
%528 = load i32, i32* %11
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds i8, i8* %527, i64 %529
%531 = load i8, i8* %530
%532 = sext i8 %531 to i32
%533 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %532)
%534 = icmp ne i32 %533, 0
br label %535
535: ; preds = %526, %522
%536 = phi i1 [ false, %522 ], [ %534, %526 ]
br i1 %536, label %537, label %540
537: ; preds = %535
%538 = load i32, i32* %11
%539 = add nsw i32 %538, 1
store i32 %539, i32* %11
br label %522
540: ; preds = %535
%541 = load i32, i32* %10
%542 = load i32, i32* %7
%543 = sub nsw i32 %541, %542
store i32 %543, i32* %12
%544 = load i32, i32* %12
%545 = load i32, i32* %8
%546 = load i32, i32* %11
%547 = sub nsw i32 %545, %546
%548 = icmp sgt i32 %544, %547
br i1 %548, label %549, label %553
549: ; preds = %540
%550 = load i32, i32* %8
%551 = load i32, i32* %11
%552 = sub nsw i32 %550, %551
store i32 %552, i32* %12
br label %553
553: ; preds = %549, %540
%554 = load i8*, i8** %6
%555 = load i32, i32* %7
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds i8, i8* %554, i64 %556
%558 = load i8*, i8** %6
%559 = load i32, i32* %11
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds i8, i8* %558, i64 %560
%562 = load i32, i32* %12
%563 = sext i32 %562 to i64
%564 = call i32 @strncmp(i8* %557, i8* %561, i64 %563)
store i32 %564, i32* %13
%565 = load i32, i32* %13
%566 = icmp sgt i32 %565, 0
br i1 %566, label %580, label %567
567: ; preds = %553
%568 = load i32, i32* %13
%569 = icmp eq i32 %568, 0
br i1 %569, label %570, label %578
570: ; preds = %567
%571 = load i32, i32* %10
%572 = load i32, i32* %7
%573 = sub nsw i32 %571, %572
%574 = load i32, i32* %8
%575 = load i32, i32* %11
%576 = sub nsw i32 %574, %575
%577 = icmp sgt i32 %573, %576
br label %578
578: ; preds = %570, %567
%579 = phi i1 [ false, %567 ], [ %577, %570 ]
br label %580
580: ; preds = %578, %553
%581 = phi i1 [ true, %553 ], [ %579, %578 ]
%582 = zext i1 %581 to i32
%583 = load i32*, i32** %9
store i32 %582, i32* %583
br label %590
584: ; preds = %495
%585 = load i32, i32* %13
%586 = load i32, i32* %14
%587 = icmp sgt i32 %585, %586
%588 = zext i1 %587 to i32
%589 = load i32*, i32** %9
store i32 %588, i32* %589
br label %590
590: ; preds = %584, %580
store i32 1, i32* %5
br label %1233
591: ; preds = %483
%592 = load i8*, i8** %6
%593 = load i32, i32* %7
%594 = load i32, i32* %8
%595 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %592, i32 %593, i32 %594, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0), i32* %10, i32* %11)
%596 = icmp ne i32 %595, 0
br i1 %596, label %597, label %699
597: ; preds = %591
%598 = load i8*, i8** %6
%599 = load i32, i32* %7
%600 = load i32, i32* %10
%601 = call i32 @DoArithmEval(i8* %598, i32 %599, i32 %600, i32* %13)
%602 = icmp ne i32 %601, 0
br i1 %602, label %603, label %609
603: ; preds = %597
%604 = load i8*, i8** %6
%605 = load i32, i32* %11
%606 = load i32, i32* %8
%607 = call i32 @DoArithmEval(i8* %604, i32 %605, i32 %606, i32* %14)
%608 = icmp ne i32 %607, 0
br i1 %608, label %692, label %609
609: ; preds = %603, %597
br label %610
610: ; preds = %626, %609
%611 = load i32, i32* %7
%612 = load i32, i32* %10
%613 = icmp slt i32 %611, %612
br i1 %613, label %614, label %624
614: ; preds = %610
%615 = load i8*, i8** %6
%616 = load i32, i32* %10
%617 = sub nsw i32 %616, 1
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds i8, i8* %615, i64 %618
%620 = load i8, i8* %619
%621 = sext i8 %620 to i32
%622 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %621)
%623 = icmp ne i32 %622, 0
br label %624
624: ; preds = %614, %610
%625 = phi i1 [ false, %610 ], [ %623, %614 ]
br i1 %625, label %626, label %629
626: ; preds = %624
%627 = load i32, i32* %10
%628 = add nsw i32 %627, -1
store i32 %628, i32* %10
br label %610
629: ; preds = %624
br label %630
630: ; preds = %645, %629
%631 = load i32, i32* %8
%632 = load i32, i32* %11
%633 = icmp sgt i32 %631, %632
br i1 %633, label %634, label %643
634: ; preds = %630
%635 = load i8*, i8** %6
%636 = load i32, i32* %11
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds i8, i8* %635, i64 %637
%639 = load i8, i8* %638
%640 = sext i8 %639 to i32
%641 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %640)
%642 = icmp ne i32 %641, 0
br label %643
643: ; preds = %634, %630
%644 = phi i1 [ false, %630 ], [ %642, %634 ]
br i1 %644, label %645, label %648
645: ; preds = %643
%646 = load i32, i32* %11
%647 = add nsw i32 %646, 1
store i32 %647, i32* %11
br label %630
648: ; preds = %643
%649 = load i32, i32* %10
%650 = load i32, i32* %7
%651 = sub nsw i32 %649, %650
store i32 %651, i32* %12
%652 = load i32, i32* %12
%653 = load i32, i32* %8
%654 = load i32, i32* %11
%655 = sub nsw i32 %653, %654
%656 = icmp sgt i32 %652, %655
br i1 %656, label %657, label %661
657: ; preds = %648
%658 = load i32, i32* %8
%659 = load i32, i32* %11
%660 = sub nsw i32 %658, %659
store i32 %660, i32* %12
br label %661
661: ; preds = %657, %648
%662 = load i8*, i8** %6
%663 = load i32, i32* %7
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds i8, i8* %662, i64 %664
%666 = load i8*, i8** %6
%667 = load i32, i32* %11
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds i8, i8* %666, i64 %668
%670 = load i32, i32* %12
%671 = sext i32 %670 to i64
%672 = call i32 @strncmp(i8* %665, i8* %669, i64 %671)
store i32 %672, i32* %13
%673 = load i32, i32* %13
%674 = icmp slt i32 %673, 0
br i1 %674, label %688, label %675
675: ; preds = %661
%676 = load i32, i32* %13
%677 = icmp eq i32 %676, 0
br i1 %677, label %678, label %686
678: ; preds = %675
%679 = load i32, i32* %10
%680 = load i32, i32* %7
%681 = sub nsw i32 %679, %680
%682 = load i32, i32* %8
%683 = load i32, i32* %11
%684 = sub nsw i32 %682, %683
%685 = icmp sle i32 %681, %684
br label %686
686: ; preds = %678, %675
%687 = phi i1 [ false, %675 ], [ %685, %678 ]
br label %688
688: ; preds = %686, %661
%689 = phi i1 [ true, %661 ], [ %687, %686 ]
%690 = zext i1 %689 to i32
%691 = load i32*, i32** %9
store i32 %690, i32* %691
br label %698
692: ; preds = %603
%693 = load i32, i32* %13
%694 = load i32, i32* %14
%695 = icmp sle i32 %693, %694
%696 = zext i1 %695 to i32
%697 = load i32*, i32** %9
store i32 %696, i32* %697
br label %698
698: ; preds = %692, %688
store i32 1, i32* %5
br label %1233
699: ; preds = %591
%700 = load i8*, i8** %6
%701 = load i32, i32* %7
%702 = load i32, i32* %8
%703 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %700, i32 %701, i32 %702, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0), i32* %10, i32* %11)
%704 = icmp ne i32 %703, 0
br i1 %704, label %705, label %807
705: ; preds = %699
%706 = load i8*, i8** %6
%707 = load i32, i32* %7
%708 = load i32, i32* %10
%709 = call i32 @DoArithmEval(i8* %706, i32 %707, i32 %708, i32* %13)
%710 = icmp ne i32 %709, 0
br i1 %710, label %711, label %717
711: ; preds = %705
%712 = load i8*, i8** %6
%713 = load i32, i32* %11
%714 = load i32, i32* %8
%715 = call i32 @DoArithmEval(i8* %712, i32 %713, i32 %714, i32* %14)
%716 = icmp ne i32 %715, 0
br i1 %716, label %800, label %717
717: ; preds = %711, %705
br label %718
718: ; preds = %734, %717
%719 = load i32, i32* %7
%720 = load i32, i32* %10
%721 = icmp slt i32 %719, %720
br i1 %721, label %722, label %732
722: ; preds = %718
%723 = load i8*, i8** %6
%724 = load i32, i32* %10
%725 = sub nsw i32 %724, 1
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds i8, i8* %723, i64 %726
%728 = load i8, i8* %727
%729 = sext i8 %728 to i32
%730 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %729)
%731 = icmp ne i32 %730, 0
br label %732
732: ; preds = %722, %718
%733 = phi i1 [ false, %718 ], [ %731, %722 ]
br i1 %733, label %734, label %737
734: ; preds = %732
%735 = load i32, i32* %10
%736 = add nsw i32 %735, -1
store i32 %736, i32* %10
br label %718
737: ; preds = %732
br label %738
738: ; preds = %753, %737
%739 = load i32, i32* %8
%740 = load i32, i32* %11
%741 = icmp sgt i32 %739, %740
br i1 %741, label %742, label %751
742: ; preds = %738
%743 = load i8*, i8** %6
%744 = load i32, i32* %11
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds i8, i8* %743, i64 %745
%747 = load i8, i8* %746
%748 = sext i8 %747 to i32
%749 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %748)
%750 = icmp ne i32 %749, 0
br label %751
751: ; preds = %742, %738
%752 = phi i1 [ false, %738 ], [ %750, %742 ]
br i1 %752, label %753, label %756
753: ; preds = %751
%754 = load i32, i32* %11
%755 = add nsw i32 %754, 1
store i32 %755, i32* %11
br label %738
756: ; preds = %751
%757 = load i32, i32* %10
%758 = load i32, i32* %7
%759 = sub nsw i32 %757, %758
store i32 %759, i32* %12
%760 = load i32, i32* %12
%761 = load i32, i32* %8
%762 = load i32, i32* %11
%763 = sub nsw i32 %761, %762
%764 = icmp sgt i32 %760, %763
br i1 %764, label %765, label %769
765: ; preds = %756
%766 = load i32, i32* %8
%767 = load i32, i32* %11
%768 = sub nsw i32 %766, %767
store i32 %768, i32* %12
br label %769
769: ; preds = %765, %756
%770 = load i8*, i8** %6
%771 = load i32, i32* %7
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds i8, i8* %770, i64 %772
%774 = load i8*, i8** %6
%775 = load i32, i32* %11
%776 = sext i32 %775 to i64
%777 = getelementptr inbounds i8, i8* %774, i64 %776
%778 = load i32, i32* %12
%779 = sext i32 %778 to i64
%780 = call i32 @strncmp(i8* %773, i8* %777, i64 %779)
store i32 %780, i32* %13
%781 = load i32, i32* %13
%782 = icmp slt i32 %781, 0
br i1 %782, label %796, label %783
783: ; preds = %769
%784 = load i32, i32* %13
%785 = icmp eq i32 %784, 0
br i1 %785, label %786, label %794
786: ; preds = %783
%787 = load i32, i32* %10
%788 = load i32, i32* %7
%789 = sub nsw i32 %787, %788
%790 = load i32, i32* %8
%791 = load i32, i32* %11
%792 = sub nsw i32 %790, %791
%793 = icmp slt i32 %789, %792
br label %794
794: ; preds = %786, %783
%795 = phi i1 [ false, %783 ], [ %793, %786 ]
br label %796
796: ; preds = %794, %769
%797 = phi i1 [ true, %769 ], [ %795, %794 ]
%798 = zext i1 %797 to i32
%799 = load i32*, i32** %9
store i32 %798, i32* %799
br label %806
800: ; preds = %711
%801 = load i32, i32* %13
%802 = load i32, i32* %14
%803 = icmp slt i32 %801, %802
%804 = zext i1 %803 to i32
%805 = load i32*, i32** %9
store i32 %804, i32* %805
br label %806
806: ; preds = %800, %796
store i32 1, i32* %5
br label %1233
807: ; preds = %699
%808 = load i8*, i8** %6
%809 = load i32, i32* %7
%810 = load i32, i32* %8
%811 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %808, i32 %809, i32 %810, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0), i32* %10, i32* %11)
%812 = icmp ne i32 %811, 0
br i1 %812, label %813, label %831
813: ; preds = %807
%814 = load i8*, i8** %6
%815 = load i32, i32* %7
%816 = load i32, i32* %10
%817 = call i32 @DoArithmEval(i8* %814, i32 %815, i32 %816, i32* %13)
%818 = icmp ne i32 %817, 0
br i1 %818, label %819, label %825
819: ; preds = %813
%820 = load i8*, i8** %6
%821 = load i32, i32* %11
%822 = load i32, i32* %8
%823 = call i32 @DoArithmEval(i8* %820, i32 %821, i32 %822, i32* %14)
%824 = icmp ne i32 %823, 0
br i1 %824, label %826, label %825
825: ; preds = %819, %813
store i32 0, i32* %5
br label %1233
826: ; preds = %819
%827 = load i32, i32* %13
%828 = load i32, i32* %14
%829 = add nsw i32 %827, %828
%830 = load i32*, i32** %9
store i32 %829, i32* %830
store i32 1, i32* %5
br label %1233
831: ; preds = %807
%832 = load i8*, i8** %6
%833 = load i32, i32* %7
%834 = load i32, i32* %8
%835 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %832, i32 %833, i32 %834, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i32* %10, i32* %11)
%836 = icmp ne i32 %835, 0
br i1 %836, label %837, label %860
837: ; preds = %831
%838 = load i32, i32* %10
%839 = load i32, i32* %7
%840 = icmp ne i32 %838, %839
br i1 %840, label %841, label %859
841: ; preds = %837
%842 = load i8*, i8** %6
%843 = load i32, i32* %7
%844 = load i32, i32* %10
%845 = call i32 @DoArithmEval(i8* %842, i32 %843, i32 %844, i32* %13)
%846 = icmp ne i32 %845, 0
br i1 %846, label %847, label %853
847: ; preds = %841
%848 = load i8*, i8** %6
%849 = load i32, i32* %11
%850 = load i32, i32* %8
%851 = call i32 @DoArithmEval(i8* %848, i32 %849, i32 %850, i32* %14)
%852 = icmp ne i32 %851, 0
br i1 %852, label %854, label %853
853: ; preds = %847, %841
store i32 0, i32* %5
br label %1233
854: ; preds = %847
%855 = load i32, i32* %13
%856 = load i32, i32* %14
%857 = sub nsw i32 %855, %856
%858 = load i32*, i32** %9
store i32 %857, i32* %858
store i32 1, i32* %5
br label %1233
859: ; preds = %837
br label %860
860: ; preds = %859, %831
%861 = load i8*, i8** %6
%862 = load i32, i32* %7
%863 = load i32, i32* %8
%864 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %861, i32 %862, i32 %863, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0), i32* %10, i32* %11)
%865 = icmp ne i32 %864, 0
br i1 %865, label %866, label %884
866: ; preds = %860
%867 = load i8*, i8** %6
%868 = load i32, i32* %7
%869 = load i32, i32* %10
%870 = call i32 @DoArithmEval(i8* %867, i32 %868, i32 %869, i32* %13)
%871 = icmp ne i32 %870, 0
br i1 %871, label %872, label %878
872: ; preds = %866
%873 = load i8*, i8** %6
%874 = load i32, i32* %11
%875 = load i32, i32* %8
%876 = call i32 @DoArithmEval(i8* %873, i32 %874, i32 %875, i32* %14)
%877 = icmp ne i32 %876, 0
br i1 %877, label %879, label %878
878: ; preds = %872, %866
store i32 0, i32* %5
br label %1233
879: ; preds = %872
%880 = load i32, i32* %13
%881 = load i32, i32* %14
%882 = mul nsw i32 %880, %881
%883 = load i32*, i32** %9
store i32 %882, i32* %883
store i32 1, i32* %5
br label %1233
884: ; preds = %860
%885 = load i8*, i8** %6
%886 = load i32, i32* %7
%887 = load i32, i32* %8
%888 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %885, i32 %886, i32 %887, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), i32* %10, i32* %11)
%889 = icmp ne i32 %888, 0
br i1 %889, label %890, label %913
890: ; preds = %884
%891 = load i8*, i8** %6
%892 = load i32, i32* %7
%893 = load i32, i32* %10
%894 = call i32 @DoArithmEval(i8* %891, i32 %892, i32 %893, i32* %13)
%895 = icmp ne i32 %894, 0
br i1 %895, label %896, label %902
896: ; preds = %890
%897 = load i8*, i8** %6
%898 = load i32, i32* %11
%899 = load i32, i32* %8
%900 = call i32 @DoArithmEval(i8* %897, i32 %898, i32 %899, i32* %14)
%901 = icmp ne i32 %900, 0
br i1 %901, label %903, label %902
902: ; preds = %896, %890
store i32 0, i32* %5
br label %1233
903: ; preds = %896
%904 = load i32, i32* %14
%905 = icmp eq i32 %904, 0
br i1 %905, label %906, label %908
906: ; preds = %903
%907 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.15, i64 0, i64 0))
br label %908
908: ; preds = %906, %903
%909 = load i32, i32* %13
%910 = load i32, i32* %14
%911 = sdiv i32 %909, %910
%912 = load i32*, i32** %9
store i32 %911, i32* %912
store i32 1, i32* %5
br label %1233
913: ; preds = %884
%914 = load i8*, i8** %6
%915 = load i32, i32* %7
%916 = load i32, i32* %8
%917 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %914, i32 %915, i32 %916, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i32* %10, i32* %11)
%918 = icmp ne i32 %917, 0
br i1 %918, label %919, label %942
919: ; preds = %913
%920 = load i8*, i8** %6
%921 = load i32, i32* %7
%922 = load i32, i32* %10
%923 = call i32 @DoArithmEval(i8* %920, i32 %921, i32 %922, i32* %13)
%924 = icmp ne i32 %923, 0
br i1 %924, label %925, label %931
925: ; preds = %919
%926 = load i8*, i8** %6
%927 = load i32, i32* %11
%928 = load i32, i32* %8
%929 = call i32 @DoArithmEval(i8* %926, i32 %927, i32 %928, i32* %14)
%930 = icmp ne i32 %929, 0
br i1 %930, label %932, label %931
931: ; preds = %925, %919
store i32 0, i32* %5
br label %1233
932: ; preds = %925
%933 = load i32, i32* %14
%934 = icmp eq i32 %933, 0
br i1 %934, label %935, label %937
935: ; preds = %932
%936 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.15, i64 0, i64 0))
br label %937
937: ; preds = %935, %932
%938 = load i32, i32* %13
%939 = load i32, i32* %14
%940 = srem i32 %938, %939
%941 = load i32*, i32** %9
store i32 %940, i32* %941
store i32 1, i32* %5
br label %1233
942: ; preds = %913
%943 = load i8*, i8** %6
%944 = load i32, i32* %7
%945 = sext i32 %944 to i64
%946 = getelementptr inbounds i8, i8* %943, i64 %945
%947 = load i8, i8* %946
%948 = sext i8 %947 to i32
%949 = icmp eq i32 %948, 126
br i1 %949, label %950, label %962
950: ; preds = %942
%951 = load i8*, i8** %6
%952 = load i32, i32* %7
%953 = add nsw i32 %952, 1
%954 = load i32, i32* %8
%955 = call i32 @DoArithmEval(i8* %951, i32 %953, i32 %954, i32* %13)
%956 = icmp ne i32 %955, 0
br i1 %956, label %958, label %957
957: ; preds = %950
store i32 0, i32* %5
br label %1233
958: ; preds = %950
%959 = load i32, i32* %13
%960 = xor i32 %959, -1
%961 = load i32*, i32** %9
store i32 %960, i32* %961
store i32 1, i32* %5
br label %1233
962: ; preds = %942
%963 = load i8*, i8** %6
%964 = load i32, i32* %7
%965 = sext i32 %964 to i64
%966 = getelementptr inbounds i8, i8* %963, i64 %965
%967 = load i8, i8* %966
%968 = sext i8 %967 to i32
%969 = icmp eq i32 %968, 33
br i1 %969, label %970, label %984
970: ; preds = %962
%971 = load i8*, i8** %6
%972 = load i32, i32* %7
%973 = add nsw i32 %972, 1
%974 = load i32, i32* %8
%975 = call i32 @DoArithmEval(i8* %971, i32 %973, i32 %974, i32* %13)
%976 = icmp ne i32 %975, 0
br i1 %976, label %978, label %977
977: ; preds = %970
store i32 0, i32* %5
br label %1233
978: ; preds = %970
%979 = load i32, i32* %13
%980 = icmp ne i32 %979, 0
%981 = xor i1 %980, true
%982 = zext i1 %981 to i32
%983 = load i32*, i32** %9
store i32 %982, i32* %983
store i32 1, i32* %5
br label %1233
984: ; preds = %962
%985 = load i8*, i8** %6
%986 = load i32, i32* %7
%987 = sext i32 %986 to i64
%988 = getelementptr inbounds i8, i8* %985, i64 %987
%989 = load i8, i8* %988
%990 = sext i8 %989 to i32
%991 = icmp eq i32 %990, 45
br i1 %991, label %992, label %1004
992: ; preds = %984
%993 = load i8*, i8** %6
%994 = load i32, i32* %7
%995 = add nsw i32 %994, 1
%996 = load i32, i32* %8
%997 = call i32 @DoArithmEval(i8* %993, i32 %995, i32 %996, i32* %13)
%998 = icmp ne i32 %997, 0
br i1 %998, label %1000, label %999
999: ; preds = %992
store i32 0, i32* %5
br label %1233
1000: ; preds = %992
%1001 = load i32, i32* %13
%1002 = sub nsw i32 0, %1001
%1003 = load i32*, i32** %9
store i32 %1002, i32* %1003
store i32 1, i32* %5
br label %1233
1004: ; preds = %984
%1005 = load i8*, i8** %6
%1006 = load i32, i32* %7
%1007 = sext i32 %1006 to i64
%1008 = getelementptr inbounds i8, i8* %1005, i64 %1007
%1009 = call i32 @strncmp(i8* %1008, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.17, i64 0, i64 0), i64 7)
%1010 = icmp eq i32 %1009, 0
br i1 %1010, label %1011, label %1027
1011: ; preds = %1004
%1012 = load i8*, i8** %6
%1013 = load i32, i32* %8
%1014 = sub nsw i32 %1013, 1
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds i8, i8* %1012, i64 %1015
%1017 = load i8, i8* %1016
%1018 = sext i8 %1017 to i32
%1019 = icmp ne i32 %1018, 41
br i1 %1019, label %1020, label %1021
1020: ; preds = %1011
store i32 0, i32* %5
br label %1233
1021: ; preds = %1011
%1022 = load i32, i32* %8
%1023 = load i32, i32* %7
%1024 = sub nsw i32 %1022, %1023
%1025 = sub nsw i32 %1024, 8
%1026 = load i32*, i32** %9
store i32 %1025, i32* %1026
store i32 1, i32* %5
br label %1233
1027: ; preds = %1004
%1028 = load i8*, i8** %6
%1029 = load i32, i32* %7
%1030 = sext i32 %1029 to i64
%1031 = getelementptr inbounds i8, i8* %1028, i64 %1030
%1032 = call i32 @strncmp(i8* %1031, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0), i64 7)
%1033 = icmp eq i32 %1032, 0
br i1 %1033, label %1034, label %1178
1034: ; preds = %1027
%1035 = load i32, i32* %7
%1036 = add nsw i32 %1035, 7
store i32 %1036, i32* %7
%1037 = load i32, i32* %7
%1038 = load i32, i32* %8
%1039 = icmp sle i32 %1037, %1038
br i1 %1039, label %1040, label %1051
1040: ; preds = %1034
%1041 = load i8*, i8** %6
%1042 = load i32, i32* %8
%1043 = sext i32 %1042 to i64
%1044 = getelementptr inbounds i8, i8* %1041, i64 %1043
%1045 = load i8, i8* %1044
%1046 = sext i8 %1045 to i32
%1047 = icmp eq i32 %1046, 0
br i1 %1047, label %1048, label %1051
1048: ; preds = %1040
%1049 = load i32, i32* %8
%1050 = add nsw i32 %1049, -1
store i32 %1050, i32* %8
br label %1051
1051: ; preds = %1048, %1040, %1034
br label %1052
1052: ; preds = %1067, %1051
%1053 = load i32, i32* %7
%1054 = load i32, i32* %8
%1055 = icmp sle i32 %1053, %1054
br i1 %1055, label %1056, label %1065
1056: ; preds = %1052
%1057 = load i8*, i8** %6
%1058 = load i32, i32* %7
%1059 = sext i32 %1058 to i64
%1060 = getelementptr inbounds i8, i8* %1057, i64 %1059
%1061 = load i8, i8* %1060
%1062 = sext i8 %1061 to i32
%1063 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %1062)
%1064 = icmp ne i32 %1063, 0
br label %1065
1065: ; preds = %1056, %1052
%1066 = phi i1 [ false, %1052 ], [ %1064, %1056 ]
br i1 %1066, label %1067, label %1070
1067: ; preds = %1065
%1068 = load i32, i32* %7
%1069 = add nsw i32 %1068, 1
store i32 %1069, i32* %7
br label %1052
1070: ; preds = %1065
br label %1071
1071: ; preds = %1086, %1070
%1072 = load i32, i32* %7
%1073 = load i32, i32* %8
%1074 = icmp sle i32 %1072, %1073
br i1 %1074, label %1075, label %1084
1075: ; preds = %1071
%1076 = load i8*, i8** %6
%1077 = load i32, i32* %8
%1078 = sext i32 %1077 to i64
%1079 = getelementptr inbounds i8, i8* %1076, i64 %1078
%1080 = load i8, i8* %1079
%1081 = sext i8 %1080 to i32
%1082 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %1081)
%1083 = icmp ne i32 %1082, 0
br label %1084
1084: ; preds = %1075, %1071
%1085 = phi i1 [ false, %1071 ], [ %1083, %1075 ]
br i1 %1085, label %1086, label %1089
1086: ; preds = %1084
%1087 = load i32, i32* %8
%1088 = add nsw i32 %1087, -1
store i32 %1088, i32* %8
br label %1071
1089: ; preds = %1084
%1090 = load i8*, i8** %6
%1091 = load i32, i32* %8
%1092 = sext i32 %1091 to i64
%1093 = getelementptr inbounds i8, i8* %1090, i64 %1092
%1094 = load i8, i8* %1093
%1095 = sext i8 %1094 to i32
%1096 = icmp ne i32 %1095, 41
br i1 %1096, label %1097, label %1099
1097: ; preds = %1089
%1098 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.19, i64 0, i64 0))
br label %1102
1099: ; preds = %1089
%1100 = load i32, i32* %8
%1101 = add nsw i32 %1100, -1
store i32 %1101, i32* %8
br label %1102
1102: ; preds = %1099, %1097
%1103 = load i8*, i8** %6
%1104 = load i32, i32* %7
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds i8, i8* %1103, i64 %1105
%1107 = load i8, i8* %1106
%1108 = sext i8 %1107 to i32
%1109 = icmp eq i32 %1108, 34
br i1 %1109, label %1118, label %1110
1110: ; preds = %1102
%1111 = load i8*, i8** %6
%1112 = load i32, i32* %7
%1113 = sext i32 %1112 to i64
%1114 = getelementptr inbounds i8, i8* %1111, i64 %1113
%1115 = load i8, i8* %1114
%1116 = sext i8 %1115 to i32
%1117 = icmp eq i32 %1116, 60
br i1 %1117, label %1118, label %1121
1118: ; preds = %1110, %1102
%1119 = load i32, i32* %7
%1120 = add nsw i32 %1119, 1
store i32 %1120, i32* %7
br label %1121
1121: ; preds = %1118, %1110
%1122 = load i8*, i8** %6
%1123 = load i32, i32* %8
%1124 = sext i32 %1123 to i64
%1125 = getelementptr inbounds i8, i8* %1122, i64 %1124
%1126 = load i8, i8* %1125
%1127 = sext i8 %1126 to i32
%1128 = icmp eq i32 %1127, 34
br i1 %1128, label %1137, label %1129
1129: ; preds = %1121
%1130 = load i8*, i8** %6
%1131 = load i32, i32* %8
%1132 = sext i32 %1131 to i64
%1133 = getelementptr inbounds i8, i8* %1130, i64 %1132
%1134 = load i8, i8* %1133
%1135 = sext i8 %1134 to i32
%1136 = icmp eq i32 %1135, 62
br i1 %1136, label %1137, label %1140
1137: ; preds = %1129, %1121
%1138 = load i32, i32* %8
%1139 = add nsw i32 %1138, -1
store i32 %1139, i32* %8
br label %1140
1140: ; preds = %1137, %1129
%1141 = load i32, i32* %7
%1142 = load i32, i32* %8
%1143 = icmp sgt i32 %1141, %1142
br i1 %1143, label %1144, label %1146
1144: ; preds = %1140
%1145 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.20, i64 0, i64 0))
br label %1146
1146: ; preds = %1144, %1140
%1147 = load i32, i32* %8
%1148 = load i32, i32* %7
%1149 = sub nsw i32 %1147, %1148
%1150 = add nsw i32 %1149, 2
%1151 = sext i32 %1150 to i64
%1152 = call i8* @malloc(i64 %1151)
store i8* %1152, i8** %17
%1153 = load i8*, i8** %17
%1154 = load i8*, i8** %6
%1155 = load i32, i32* %7
%1156 = sext i32 %1155 to i64
%1157 = getelementptr inbounds i8, i8* %1154, i64 %1156
%1158 = load i32, i32* %8
%1159 = load i32, i32* %7
%1160 = sub nsw i32 %1158, %1159
%1161 = add nsw i32 %1160, 1
%1162 = sext i32 %1161 to i64
%1163 = load i8*, i8** %17
%1164 = load i32, i32* %8
%1165 = load i32, i32* %7
%1166 = sub nsw i32 %1164, %1165
%1167 = add nsw i32 %1166, 1
%1168 = sext i32 %1167 to i64
%1169 = getelementptr inbounds i8, i8* %1163, i64 %1168
store i8 0, i8* %1169
%1170 = load i8*, i8** %17
%1171 = call i32 (i8*, ...) bitcast (i32 (...)* @checkAbsOrCurrentDir to i32 (i8*, ...)*)(i8* %1170)
%1172 = icmp eq i32 %1171, 0
br i1 %1172, label %1173, label %1175
1173: ; preds = %1146
%1174 = load i32*, i32** %9
store i32 0, i32* %1174
br label %1177
1175: ; preds = %1146
%1176 = load i32*, i32** %9
store i32 1, i32* %1176
br label %1177
1177: ; preds = %1175, %1173
store i32 1, i32* %5
br label %1233
1178: ; preds = %1027
%1179 = load i8*, i8** %6
%1180 = load i32, i32* %7
%1181 = sext i32 %1180 to i64
%1182 = getelementptr inbounds i8, i8* %1179, i64 %1181
%1183 = load i8, i8* %1182
%1184 = sext i8 %1183 to i32
%1185 = icmp eq i32 %1184, 40
br i1 %1185, label %1186, label %1204
1186: ; preds = %1178
%1187 = load i8*, i8** %6
%1188 = load i32, i32* %8
%1189 = sub nsw i32 %1188, 1
%1190 = sext i32 %1189 to i64
%1191 = getelementptr inbounds i8, i8* %1187, i64 %1190
%1192 = load i8, i8* %1191
%1193 = sext i8 %1192 to i32
%1194 = icmp ne i32 %1193, 41
br i1 %1194, label %1195, label %1196
1195: ; preds = %1186
store i32 0, i32* %5
br label %1233
1196: ; preds = %1186
%1197 = load i8*, i8** %6
%1198 = load i32, i32* %7
%1199 = add nsw i32 %1198, 1
%1200 = load i32, i32* %8
%1201 = sub nsw i32 %1200, 1
%1202 = load i32*, i32** %9
%1203 = call i32 @DoArithmEval(i8* %1197, i32 %1199, i32 %1201, i32* %1202)
store i32 %1203, i32* %5
br label %1233
1204: ; preds = %1178
%1205 = load i8*, i8** %6
%1206 = load i32, i32* %8
%1207 = sext i32 %1206 to i64
%1208 = getelementptr inbounds i8, i8* %1205, i64 %1207
%1209 = load i8, i8* %1208
store i8 %1209, i8* %15
%1210 = load i8*, i8** %6
%1211 = load i32, i32* %8
%1212 = sext i32 %1211 to i64
%1213 = getelementptr inbounds i8, i8* %1210, i64 %1212
store i8 0, i8* %1213
%1214 = load i8*, i8** %6
%1215 = load i32, i32* %7
%1216 = sext i32 %1215 to i64
%1217 = getelementptr inbounds i8, i8* %1214, i64 %1216
%1218 = call i64 @strtol(i8* %1217, i8** %16, i32 0)
%1219 = trunc i64 %1218 to i32
%1220 = load i32*, i32** %9
store i32 %1219, i32* %1220
%1221 = load i8, i8* %15
%1222 = load i8*, i8** %6
%1223 = load i32, i32* %8
%1224 = sext i32 %1223 to i64
%1225 = getelementptr inbounds i8, i8* %1222, i64 %1224
store i8 %1221, i8* %1225
%1226 = load i8*, i8** %16
%1227 = load i8*, i8** %6
%1228 = load i32, i32* %8
%1229 = sext i32 %1228 to i64
%1230 = getelementptr inbounds i8, i8* %1227, i64 %1229
%1231 = icmp eq i8* %1226, %1230
%1232 = zext i1 %1231 to i32
store i32 %1232, i32* %5
br label %1233
1233: ; preds = %1204, %1196, %1195, %1177, %1021, %1020, %1000, %999, %978, %977, %958, %957, %937, %931, %908, %902, %879, %878, %854, %853, %826, %825, %806, %698, %590, %482, %374, %282, %186, %185, %162, %161, %138, %137, %115, %108, %86, %79, %60
%1234 = load i32, i32* %5
ret i32 %1234
}

LLVM IR (-O2):
@.str = [3 x i8] c"||\00"
@.str.1 = [3 x i8] c"&&\00"
@.str.2 = [2 x i8] c"|\00"
@.str.3 = [2 x i8] c"^\00"
@.str.4 = [2 x i8] c"&\00"
@.str.5 = [3 x i8] c"!=\00"
@.str.6 = [3 x i8] c"==\00"
@.str.7 = [3 x i8] c">=\00"
@.str.8 = [2 x i8] c">\00"
@.str.9 = [3 x i8] c"<=\00"
@.str.10 = [2 x i8] c"<\00"
@.str.11 = [2 x i8] c"+\00"
@.str.12 = [2 x i8] c"-\00"
@.str.13 = [2 x i8] c"*\00"
@.str.14 = [2 x i8] c"/\00"
@.str.15 = [31 x i8] c"Division by zero in expression\00"
@.str.16 = [2 x i8] c"%\00"
@.str.17 = [8 x i8] c"length(\00"
@.str.18 = [8 x i8] c"exists(\00"
@.str.19 = [31 x i8] c"Wrong syntax in exists(\22file\22)\00"
@.str.20 = [36 x i8] c"Missing file name in exists(\22file\22)\00"
define i32 @DoArithmEval(i8* %0, i32 %1, i32 %2, i32* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = bitcast i32* %5 to i8*
%11 = bitcast i32* %6 to i8*
%12 = bitcast i32* %7 to i8*
%13 = bitcast i32* %8 to i8*
%14 = bitcast i8** %9 to i8*
%15 = icmp slt i32 %1, %2
br i1 %15, label %16, label %31
16: ; preds = %4
%17 = sext i32 %1 to i64
br label %18
18: ; preds = %16, %25
%19 = phi i64 [ %17, %16 ], [ %26, %25 ]
%20 = getelementptr inbounds i8, i8* %0, i64 %19
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = tail call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %22)
%24 = icmp eq i32 %23, 0
br i1 %24, label %29, label %25
25: ; preds = %18
%26 = add nsw i64 %19, 1
%27 = trunc i64 %26 to i32
%28 = icmp eq i32 %27, %2
br i1 %28, label %31, label %18
29: ; preds = %18
%30 = trunc i64 %19 to i32
br label %31
31: ; preds = %25, %29, %4
%32 = phi i32 [ %1, %4 ], [ %30, %29 ], [ %2, %25 ]
%33 = sext i32 %2 to i64
%34 = sext i32 %32 to i64
%35 = call i32 @llvm.smin.i32(i32 %32, i32 %2)
br label %36
36: ; preds = %39, %31
%37 = phi i64 [ %40, %39 ], [ %33, %31 ]
%38 = icmp sgt i64 %37, %34
br i1 %38, label %39, label %48
39: ; preds = %36
%40 = add nsw i64 %37, -1
%41 = getelementptr inbounds i8, i8* %0, i64 %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = tail call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %43)
%45 = icmp eq i32 %44, 0
br i1 %45, label %46, label %36
46: ; preds = %39
%47 = trunc i64 %37 to i32
br label %48
48: ; preds = %36, %46
%49 = phi i32 [ %47, %46 ], [ %35, %36 ]
%50 = icmp eq i32 %49, %32
br i1 %50, label %758, label %51
51: ; preds = %48
%52 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %5, i32* %6)
%53 = icmp eq i32 %52, 0
br i1 %53, label %69, label %54
54: ; preds = %51
%55 = load i32, i32* %5
%56 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %55, i32* %7)
%57 = icmp eq i32 %56, 0
br i1 %57, label %758, label %58
58: ; preds = %54
%59 = load i32, i32* %6
%60 = call i32 @DoArithmEval(i8* %0, i32 %59, i32 %49, i32* %8)
%61 = icmp eq i32 %60, 0
br i1 %61, label %758, label %62
62: ; preds = %58
%63 = load i32, i32* %7
%64 = icmp ne i32 %63, 0
%65 = load i32, i32* %8
%66 = icmp ne i32 %65, 0
%67 = select i1 %64, i1 true, i1 %66
%68 = zext i1 %67 to i32
store i32 %68, i32* %3
br label %758
69: ; preds = %51
%70 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %5, i32* %6)
%71 = icmp eq i32 %70, 0
br i1 %71, label %87, label %72
72: ; preds = %69
%73 = load i32, i32* %5
%74 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %73, i32* %7)
%75 = icmp eq i32 %74, 0
br i1 %75, label %758, label %76
76: ; preds = %72
%77 = load i32, i32* %6
%78 = call i32 @DoArithmEval(i8* %0, i32 %77, i32 %49, i32* %8)
%79 = icmp eq i32 %78, 0
br i1 %79, label %758, label %80
80: ; preds = %76
%81 = load i32, i32* %7
%82 = icmp ne i32 %81, 0
%83 = load i32, i32* %8
%84 = icmp ne i32 %83, 0
%85 = select i1 %82, i1 %84, i1 false
%86 = zext i1 %85 to i32
store i32 %86, i32* %3
br label %758
87: ; preds = %69
%88 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32* %5, i32* %6)
%89 = icmp eq i32 %88, 0
br i1 %89, label %102, label %90
90: ; preds = %87
%91 = load i32, i32* %5
%92 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %91, i32* %7)
%93 = icmp eq i32 %92, 0
br i1 %93, label %758, label %94
94: ; preds = %90
%95 = load i32, i32* %6
%96 = call i32 @DoArithmEval(i8* %0, i32 %95, i32 %49, i32* %8)
%97 = icmp eq i32 %96, 0
br i1 %97, label %758, label %98
98: ; preds = %94
%99 = load i32, i32* %7
%100 = load i32, i32* %8
%101 = or i32 %100, %99
store i32 %101, i32* %3
br label %758
102: ; preds = %87
%103 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), i32* %5, i32* %6)
%104 = icmp eq i32 %103, 0
br i1 %104, label %117, label %105
105: ; preds = %102
%106 = load i32, i32* %5
%107 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %106, i32* %7)
%108 = icmp eq i32 %107, 0
br i1 %108, label %758, label %109
109: ; preds = %105
%110 = load i32, i32* %6
%111 = call i32 @DoArithmEval(i8* %0, i32 %110, i32 %49, i32* %8)
%112 = icmp eq i32 %111, 0
br i1 %112, label %758, label %113
113: ; preds = %109
%114 = load i32, i32* %7
%115 = load i32, i32* %8
%116 = xor i32 %115, %114
store i32 %116, i32* %3
br label %758
117: ; preds = %102
%118 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i32* %5, i32* %6)
%119 = icmp eq i32 %118, 0
br i1 %119, label %132, label %120
120: ; preds = %117
%121 = load i32, i32* %5
%122 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %121, i32* %7)
%123 = icmp eq i32 %122, 0
br i1 %123, label %758, label %124
124: ; preds = %120
%125 = load i32, i32* %6
%126 = call i32 @DoArithmEval(i8* %0, i32 %125, i32 %49, i32* %8)
%127 = icmp eq i32 %126, 0
br i1 %127, label %758, label %128
128: ; preds = %124
%129 = load i32, i32* %7
%130 = load i32, i32* %8
%131 = and i32 %130, %129
store i32 %131, i32* %3
br label %758
132: ; preds = %117
%133 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32* %5, i32* %6)
%134 = icmp eq i32 %133, 0
br i1 %134, label %194, label %135
135: ; preds = %132
%136 = load i32, i32* %5
%137 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %136, i32* %7)
%138 = icmp eq i32 %137, 0
br i1 %138, label %143, label %139
139: ; preds = %135
%140 = load i32, i32* %6
%141 = call i32 @DoArithmEval(i8* %0, i32 %140, i32 %49, i32* %8)
%142 = icmp eq i32 %141, 0
br i1 %142, label %143, label %189
143: ; preds = %139, %135
%144 = load i32, i32* %5
%145 = icmp slt i32 %32, %144
br i1 %145, label %146, label %159
146: ; preds = %143, %155
%147 = phi i32 [ %157, %155 ], [ %144, %143 ]
%148 = add nsw i32 %147, -1
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i8, i8* %0, i64 %149
%151 = load i8, i8* %150
%152 = sext i8 %151 to i32
%153 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %152)
%154 = icmp eq i32 %153, 0
br i1 %154, label %159, label %155
155: ; preds = %146
%156 = load i32, i32* %5
%157 = add nsw i32 %156, -1
store i32 %157, i32* %5
%158 = icmp slt i32 %32, %157
br i1 %158, label %146, label %159
159: ; preds = %146, %155, %143
%160 = load i32, i32* %6
%161 = icmp sgt i32 %49, %160
br i1 %161, label %162, label %174
162: ; preds = %159, %171
%163 = phi i32 [ %172, %171 ], [ %160, %159 ]
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %0, i64 %164
%166 = load i8, i8* %165
%167 = sext i8 %166 to i32
%168 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %167)
%169 = icmp eq i32 %168, 0
%170 = load i32, i32* %6
br i1 %169, label %174, label %171
171: ; preds = %162
%172 = add nsw i32 %170, 1
store i32 %172, i32* %6
%173 = icmp sgt i32 %49, %172
br i1 %173, label %162, label %174
174: ; preds = %171, %162, %159
%175 = phi i32 [ %160, %159 ], [ %170, %162 ], [ %172, %171 ]
%176 = load i32, i32* %5
%177 = sub nsw i32 %176, %32
%178 = sub nsw i32 %49, %175
%179 = icmp eq i32 %177, %178
br i1 %179, label %181, label %180
180: ; preds = %174
store i32 1, i32* %3
br label %758
181: ; preds = %174
%182 = getelementptr inbounds i8, i8* %0, i64 %34
%183 = sext i32 %175 to i64
%184 = getelementptr inbounds i8, i8* %0, i64 %183
%185 = sext i32 %177 to i64
%186 = call i32 @strncmp(i8* %182, i8* %184, i64 %185)
%187 = icmp ne i32 %186, 0
%188 = zext i1 %187 to i32
store i32 %188, i32* %3
br label %758
189: ; preds = %139
%190 = load i32, i32* %7
%191 = load i32, i32* %8
%192 = icmp ne i32 %190, %191
%193 = zext i1 %192 to i32
store i32 %193, i32* %3
br label %758
194: ; preds = %132
%195 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), i32* %5, i32* %6)
%196 = icmp eq i32 %195, 0
br i1 %196, label %256, label %197
197: ; preds = %194
%198 = load i32, i32* %5
%199 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %198, i32* %7)
%200 = icmp eq i32 %199, 0
br i1 %200, label %205, label %201
201: ; preds = %197
%202 = load i32, i32* %6
%203 = call i32 @DoArithmEval(i8* %0, i32 %202, i32 %49, i32* %8)
%204 = icmp eq i32 %203, 0
br i1 %204, label %205, label %251
205: ; preds = %201, %197
%206 = load i32, i32* %5
%207 = icmp slt i32 %32, %206
br i1 %207, label %208, label %221
208: ; preds = %205, %217
%209 = phi i32 [ %219, %217 ], [ %206, %205 ]
%210 = add nsw i32 %209, -1
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8, i8* %0, i64 %211
%213 = load i8, i8* %212
%214 = sext i8 %213 to i32
%215 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %214)
%216 = icmp eq i32 %215, 0
br i1 %216, label %221, label %217
217: ; preds = %208
%218 = load i32, i32* %5
%219 = add nsw i32 %218, -1
store i32 %219, i32* %5
%220 = icmp slt i32 %32, %219
br i1 %220, label %208, label %221
221: ; preds = %208, %217, %205
%222 = load i32, i32* %6
%223 = icmp sgt i32 %49, %222
br i1 %223, label %224, label %236
224: ; preds = %221, %233
%225 = phi i32 [ %234, %233 ], [ %222, %221 ]
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i8, i8* %0, i64 %226
%228 = load i8, i8* %227
%229 = sext i8 %228 to i32
%230 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %229)
%231 = icmp eq i32 %230, 0
%232 = load i32, i32* %6
br i1 %231, label %236, label %233
233: ; preds = %224
%234 = add nsw i32 %232, 1
store i32 %234, i32* %6
%235 = icmp sgt i32 %49, %234
br i1 %235, label %224, label %236
236: ; preds = %233, %224, %221
%237 = phi i32 [ %222, %221 ], [ %232, %224 ], [ %234, %233 ]
%238 = load i32, i32* %5
%239 = sub nsw i32 %238, %32
%240 = sub nsw i32 %49, %237
%241 = icmp eq i32 %239, %240
br i1 %241, label %243, label %242
242: ; preds = %236
store i32 0, i32* %3
br label %758
243: ; preds = %236
%244 = getelementptr inbounds i8, i8* %0, i64 %34
%245 = sext i32 %237 to i64
%246 = getelementptr inbounds i8, i8* %0, i64 %245
%247 = sext i32 %239 to i64
%248 = call i32 @strncmp(i8* %244, i8* %246, i64 %247)
%249 = icmp eq i32 %248, 0
%250 = zext i1 %249 to i32
store i32 %250, i32* %3
br label %758
251: ; preds = %201
%252 = load i32, i32* %7
%253 = load i32, i32* %8
%254 = icmp eq i32 %252, %253
%255 = zext i1 %254 to i32
store i32 %255, i32* %3
br label %758
256: ; preds = %194
%257 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32* %5, i32* %6)
%258 = icmp eq i32 %257, 0
br i1 %258, label %322, label %259
259: ; preds = %256
%260 = load i32, i32* %5
%261 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %260, i32* %7)
%262 = icmp eq i32 %261, 0
br i1 %262, label %267, label %263
263: ; preds = %259
%264 = load i32, i32* %6
%265 = call i32 @DoArithmEval(i8* %0, i32 %264, i32 %49, i32* %8)
%266 = icmp eq i32 %265, 0
br i1 %266, label %267, label %315
267: ; preds = %263, %259
%268 = load i32, i32* %5
%269 = icmp slt i32 %32, %268
br i1 %269, label %270, label %283
270: ; preds = %267, %279
%271 = phi i32 [ %281, %279 ], [ %268, %267 ]
%272 = add nsw i32 %271, -1
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds i8, i8* %0, i64 %273
%275 = load i8, i8* %274
%276 = sext i8 %275 to i32
%277 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %276)
%278 = icmp eq i32 %277, 0
br i1 %278, label %283, label %279
279: ; preds = %270
%280 = load i32, i32* %5
%281 = add nsw i32 %280, -1
store i32 %281, i32* %5
%282 = icmp slt i32 %32, %281
br i1 %282, label %270, label %283
283: ; preds = %270, %279, %267
%284 = load i32, i32* %6
%285 = icmp sgt i32 %49, %284
br i1 %285, label %286, label %298
286: ; preds = %283, %295
%287 = phi i32 [ %296, %295 ], [ %284, %283 ]
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i8, i8* %0, i64 %288
%290 = load i8, i8* %289
%291 = sext i8 %290 to i32
%292 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %291)
%293 = icmp eq i32 %292, 0
%294 = load i32, i32* %6
br i1 %293, label %298, label %295
295: ; preds = %286
%296 = add nsw i32 %294, 1
store i32 %296, i32* %6
%297 = icmp sgt i32 %49, %296
br i1 %297, label %286, label %298
298: ; preds = %295, %286, %283
%299 = phi i32 [ %284, %283 ], [ %294, %286 ], [ %296, %295 ]
%300 = load i32, i32* %5
%301 = sub nsw i32 %300, %32
%302 = sub nsw i32 %49, %299
%303 = icmp sgt i32 %301, %302
%304 = select i1 %303, i32 %302, i32 %301
%305 = getelementptr inbounds i8, i8* %0, i64 %34
%306 = sext i32 %299 to i64
%307 = getelementptr inbounds i8, i8* %0, i64 %306
%308 = sext i32 %304 to i64
%309 = call i32 @strncmp(i8* %305, i8* %307, i64 %308)
store i32 %309, i32* %7
%310 = icmp sgt i32 %309, 0
br i1 %310, label %319, label %311
311: ; preds = %298
%312 = icmp eq i32 %309, 0
%313 = icmp sge i32 %301, %302
%314 = select i1 %312, i1 %313, i1 false
br label %319
315: ; preds = %263
%316 = load i32, i32* %7
%317 = load i32, i32* %8
%318 = icmp sge i32 %316, %317
br label %319
319: ; preds = %311, %298, %315
%320 = phi i1 [ %318, %315 ], [ true, %298 ], [ %314, %311 ]
%321 = zext i1 %320 to i32
store i32 %321, i32* %3
br label %758
322: ; preds = %256
%323 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), i32* %5, i32* %6)
%324 = icmp eq i32 %323, 0
br i1 %324, label %387, label %325
325: ; preds = %322
%326 = load i32, i32* %5
%327 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %326, i32* %7)
%328 = icmp eq i32 %327, 0
br i1 %328, label %333, label %329
329: ; preds = %325
%330 = load i32, i32* %6
%331 = call i32 @DoArithmEval(i8* %0, i32 %330, i32 %49, i32* %8)
%332 = icmp eq i32 %331, 0
br i1 %332, label %333, label %380
333: ; preds = %329, %325
%334 = load i32, i32* %5
%335 = icmp slt i32 %32, %334
br i1 %335, label %336, label %349
336: ; preds = %333, %345
%337 = phi i32 [ %347, %345 ], [ %334, %333 ]
%338 = add nsw i32 %337, -1
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i8, i8* %0, i64 %339
%341 = load i8, i8* %340
%342 = sext i8 %341 to i32
%343 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %342)
%344 = icmp eq i32 %343, 0
br i1 %344, label %349, label %345
345: ; preds = %336
%346 = load i32, i32* %5
%347 = add nsw i32 %346, -1
store i32 %347, i32* %5
%348 = icmp slt i32 %32, %347
br i1 %348, label %336, label %349
349: ; preds = %336, %345, %333
%350 = load i32, i32* %6
%351 = icmp sgt i32 %49, %350
br i1 %351, label %352, label %364
352: ; preds = %349, %361
%353 = phi i32 [ %362, %361 ], [ %350, %349 ]
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i8, i8* %0, i64 %354
%356 = load i8, i8* %355
%357 = sext i8 %356 to i32
%358 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %357)
%359 = icmp eq i32 %358, 0
%360 = load i32, i32* %6
br i1 %359, label %364, label %361
361: ; preds = %352
%362 = add nsw i32 %360, 1
store i32 %362, i32* %6
%363 = icmp sgt i32 %49, %362
br i1 %363, label %352, label %364
364: ; preds = %361, %352, %349
%365 = phi i32 [ %350, %349 ], [ %360, %352 ], [ %362, %361 ]
%366 = load i32, i32* %5
%367 = sub nsw i32 %366, %32
%368 = sub nsw i32 %49, %365
%369 = icmp sgt i32 %367, %368
%370 = select i1 %369, i32 %368, i32 %367
%371 = getelementptr inbounds i8, i8* %0, i64 %34
%372 = sext i32 %365 to i64
%373 = getelementptr inbounds i8, i8* %0, i64 %372
%374 = sext i32 %370 to i64
%375 = call i32 @strncmp(i8* %371, i8* %373, i64 %374)
store i32 %375, i32* %7
%376 = icmp sgt i32 %375, 0
br i1 %376, label %384, label %377
377: ; preds = %364
%378 = icmp eq i32 %375, 0
%379 = select i1 %378, i1 %369, i1 false
br label %384
380: ; preds = %329
%381 = load i32, i32* %7
%382 = load i32, i32* %8
%383 = icmp sgt i32 %381, %382
br label %384
384: ; preds = %377, %364, %380
%385 = phi i1 [ %383, %380 ], [ true, %364 ], [ %379, %377 ]
%386 = zext i1 %385 to i32
store i32 %386, i32* %3
br label %758
387: ; preds = %322
%388 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0), i32* %5, i32* %6)
%389 = icmp eq i32 %388, 0
br i1 %389, label %453, label %390
390: ; preds = %387
%391 = load i32, i32* %5
%392 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %391, i32* %7)
%393 = icmp eq i32 %392, 0
br i1 %393, label %398, label %394
394: ; preds = %390
%395 = load i32, i32* %6
%396 = call i32 @DoArithmEval(i8* %0, i32 %395, i32 %49, i32* %8)
%397 = icmp eq i32 %396, 0
br i1 %397, label %398, label %446
398: ; preds = %394, %390
%399 = load i32, i32* %5
%400 = icmp slt i32 %32, %399
br i1 %400, label %401, label %414
401: ; preds = %398, %410
%402 = phi i32 [ %412, %410 ], [ %399, %398 ]
%403 = add nsw i32 %402, -1
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds i8, i8* %0, i64 %404
%406 = load i8, i8* %405
%407 = sext i8 %406 to i32
%408 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %407)
%409 = icmp eq i32 %408, 0
br i1 %409, label %414, label %410
410: ; preds = %401
%411 = load i32, i32* %5
%412 = add nsw i32 %411, -1
store i32 %412, i32* %5
%413 = icmp slt i32 %32, %412
br i1 %413, label %401, label %414
414: ; preds = %401, %410, %398
%415 = load i32, i32* %6
%416 = icmp sgt i32 %49, %415
br i1 %416, label %417, label %429
417: ; preds = %414, %426
%418 = phi i32 [ %427, %426 ], [ %415, %414 ]
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds i8, i8* %0, i64 %419
%421 = load i8, i8* %420
%422 = sext i8 %421 to i32
%423 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %422)
%424 = icmp eq i32 %423, 0
%425 = load i32, i32* %6
br i1 %424, label %429, label %426
426: ; preds = %417
%427 = add nsw i32 %425, 1
store i32 %427, i32* %6
%428 = icmp sgt i32 %49, %427
br i1 %428, label %417, label %429
429: ; preds = %426, %417, %414
%430 = phi i32 [ %415, %414 ], [ %425, %417 ], [ %427, %426 ]
%431 = load i32, i32* %5
%432 = sub nsw i32 %431, %32
%433 = sub nsw i32 %49, %430
%434 = icmp sgt i32 %432, %433
%435 = select i1 %434, i32 %433, i32 %432
%436 = getelementptr inbounds i8, i8* %0, i64 %34
%437 = sext i32 %430 to i64
%438 = getelementptr inbounds i8, i8* %0, i64 %437
%439 = sext i32 %435 to i64
%440 = call i32 @strncmp(i8* %436, i8* %438, i64 %439)
store i32 %440, i32* %7
%441 = icmp slt i32 %440, 0
br i1 %441, label %450, label %442
442: ; preds = %429
%443 = icmp eq i32 %440, 0
%444 = icmp sle i32 %432, %433
%445 = select i1 %443, i1 %444, i1 false
br label %450
446: ; preds = %394
%447 = load i32, i32* %7
%448 = load i32, i32* %8
%449 = icmp sle i32 %447, %448
br label %450
450: ; preds = %442, %429, %446
%451 = phi i1 [ %449, %446 ], [ true, %429 ], [ %445, %442 ]
%452 = zext i1 %451 to i32
store i32 %452, i32* %3
br label %758
453: ; preds = %387
%454 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0), i32* %5, i32* %6)
%455 = icmp eq i32 %454, 0
br i1 %455, label %519, label %456
456: ; preds = %453
%457 = load i32, i32* %5
%458 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %457, i32* %7)
%459 = icmp eq i32 %458, 0
br i1 %459, label %464, label %460
460: ; preds = %456
%461 = load i32, i32* %6
%462 = call i32 @DoArithmEval(i8* %0, i32 %461, i32 %49, i32* %8)
%463 = icmp eq i32 %462, 0
br i1 %463, label %464, label %512
464: ; preds = %460, %456
%465 = load i32, i32* %5
%466 = icmp slt i32 %32, %465
br i1 %466, label %467, label %480
467: ; preds = %464, %476
%468 = phi i32 [ %478, %476 ], [ %465, %464 ]
%469 = add nsw i32 %468, -1
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds i8, i8* %0, i64 %470
%472 = load i8, i8* %471
%473 = sext i8 %472 to i32
%474 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %473)
%475 = icmp eq i32 %474, 0
br i1 %475, label %480, label %476
476: ; preds = %467
%477 = load i32, i32* %5
%478 = add nsw i32 %477, -1
store i32 %478, i32* %5
%479 = icmp slt i32 %32, %478
br i1 %479, label %467, label %480
480: ; preds = %467, %476, %464
%481 = load i32, i32* %6
%482 = icmp sgt i32 %49, %481
br i1 %482, label %483, label %495
483: ; preds = %480, %492
%484 = phi i32 [ %493, %492 ], [ %481, %480 ]
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i8, i8* %0, i64 %485
%487 = load i8, i8* %486
%488 = sext i8 %487 to i32
%489 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %488)
%490 = icmp eq i32 %489, 0
%491 = load i32, i32* %6
br i1 %490, label %495, label %492
492: ; preds = %483
%493 = add nsw i32 %491, 1
store i32 %493, i32* %6
%494 = icmp sgt i32 %49, %493
br i1 %494, label %483, label %495
495: ; preds = %492, %483, %480
%496 = phi i32 [ %481, %480 ], [ %491, %483 ], [ %493, %492 ]
%497 = load i32, i32* %5
%498 = sub nsw i32 %497, %32
%499 = sub nsw i32 %49, %496
%500 = icmp sgt i32 %498, %499
%501 = select i1 %500, i32 %499, i32 %498
%502 = getelementptr inbounds i8, i8* %0, i64 %34
%503 = sext i32 %496 to i64
%504 = getelementptr inbounds i8, i8* %0, i64 %503
%505 = sext i32 %501 to i64
%506 = call i32 @strncmp(i8* %502, i8* %504, i64 %505)
store i32 %506, i32* %7
%507 = icmp slt i32 %506, 0
br i1 %507, label %516, label %508
508: ; preds = %495
%509 = icmp eq i32 %506, 0
%510 = icmp slt i32 %498, %499
%511 = select i1 %509, i1 %510, i1 false
br label %516
512: ; preds = %460
%513 = load i32, i32* %7
%514 = load i32, i32* %8
%515 = icmp slt i32 %513, %514
br label %516
516: ; preds = %508, %495, %512
%517 = phi i1 [ %515, %512 ], [ true, %495 ], [ %511, %508 ]
%518 = zext i1 %517 to i32
store i32 %518, i32* %3
br label %758
519: ; preds = %453
%520 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0), i32* %5, i32* %6)
%521 = icmp eq i32 %520, 0
br i1 %521, label %534, label %522
522: ; preds = %519
%523 = load i32, i32* %5
%524 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %523, i32* %7)
%525 = icmp eq i32 %524, 0
br i1 %525, label %758, label %526
526: ; preds = %522
%527 = load i32, i32* %6
%528 = call i32 @DoArithmEval(i8* %0, i32 %527, i32 %49, i32* %8)
%529 = icmp eq i32 %528, 0
br i1 %529, label %758, label %530
530: ; preds = %526
%531 = load i32, i32* %7
%532 = load i32, i32* %8
%533 = add nsw i32 %532, %531
store i32 %533, i32* %3
br label %758
534: ; preds = %519
%535 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i32* %5, i32* %6)
%536 = icmp eq i32 %535, 0
br i1 %536, label %551, label %537
537: ; preds = %534
%538 = load i32, i32* %5
%539 = icmp eq i32 %538, %32
br i1 %539, label %551, label %540
540: ; preds = %537
%541 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %538, i32* %7)
%542 = icmp eq i32 %541, 0
br i1 %542, label %758, label %543
543: ; preds = %540
%544 = load i32, i32* %6
%545 = call i32 @DoArithmEval(i8* %0, i32 %544, i32 %49, i32* %8)
%546 = icmp eq i32 %545, 0
br i1 %546, label %758, label %547
547: ; preds = %543
%548 = load i32, i32* %7
%549 = load i32, i32* %8
%550 = sub nsw i32 %548, %549
store i32 %550, i32* %3
br label %758
551: ; preds = %537, %534
%552 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0), i32* %5, i32* %6)
%553 = icmp eq i32 %552, 0
br i1 %553, label %566, label %554
554: ; preds = %551
%555 = load i32, i32* %5
%556 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %555, i32* %7)
%557 = icmp eq i32 %556, 0
br i1 %557, label %758, label %558
558: ; preds = %554
%559 = load i32, i32* %6
%560 = call i32 @DoArithmEval(i8* %0, i32 %559, i32 %49, i32* %8)
%561 = icmp eq i32 %560, 0
br i1 %561, label %758, label %562
562: ; preds = %558
%563 = load i32, i32* %7
%564 = load i32, i32* %8
%565 = mul nsw i32 %564, %563
store i32 %565, i32* %3
br label %758
566: ; preds = %551
%567 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), i32* %5, i32* %6)
%568 = icmp eq i32 %567, 0
br i1 %568, label %587, label %569
569: ; preds = %566
%570 = load i32, i32* %5
%571 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %570, i32* %7)
%572 = icmp eq i32 %571, 0
br i1 %572, label %758, label %573
573: ; preds = %569
%574 = load i32, i32* %6
%575 = call i32 @DoArithmEval(i8* %0, i32 %574, i32 %49, i32* %8)
%576 = icmp eq i32 %575, 0
br i1 %576, label %758, label %577
577: ; preds = %573
%578 = load i32, i32* %8
%579 = icmp eq i32 %578, 0
br i1 %579, label %580, label %583
580: ; preds = %577
%581 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.15, i64 0, i64 0))
%582 = load i32, i32* %8
br label %583
583: ; preds = %580, %577
%584 = phi i32 [ %582, %580 ], [ %578, %577 ]
%585 = load i32, i32* %7
%586 = sdiv i32 %585, %584
store i32 %586, i32* %3
br label %758
587: ; preds = %566
%588 = call i32 (i8*, i32, i32, i8*, i32*, i32*, ...) bitcast (i32 (...)* @SpliceInfix to i32 (i8*, i32, i32, i8*, i32*, i32*, ...)*)(i8* %0, i32 %32, i32 %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i32* %5, i32* %6)
%589 = icmp eq i32 %588, 0
br i1 %589, label %608, label %590
590: ; preds = %587
%591 = load i32, i32* %5
%592 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %591, i32* %7)
%593 = icmp eq i32 %592, 0
br i1 %593, label %758, label %594
594: ; preds = %590
%595 = load i32, i32* %6
%596 = call i32 @DoArithmEval(i8* %0, i32 %595, i32 %49, i32* %8)
%597 = icmp eq i32 %596, 0
br i1 %597, label %758, label %598
598: ; preds = %594
%599 = load i32, i32* %8
%600 = icmp eq i32 %599, 0
br i1 %600, label %601, label %604
601: ; preds = %598
%602 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.15, i64 0, i64 0))
%603 = load i32, i32* %8
br label %604
604: ; preds = %601, %598
%605 = phi i32 [ %603, %601 ], [ %599, %598 ]
%606 = load i32, i32* %7
%607 = srem i32 %606, %605
store i32 %607, i32* %3
br label %758
608: ; preds = %587
%609 = getelementptr inbounds i8, i8* %0, i64 %34
%610 = load i8, i8* %609
switch i8 %610, label %633 [
i8 126, label %611
i8 33, label %618
i8 45, label %626
]
611: ; preds = %608
%612 = add nsw i32 %32, 1
%613 = call i32 @DoArithmEval(i8* %0, i32 %612, i32 %49, i32* %7)
%614 = icmp eq i32 %613, 0
br i1 %614, label %758, label %615
615: ; preds = %611
%616 = load i32, i32* %7
%617 = xor i32 %616, -1
store i32 %617, i32* %3
br label %758
618: ; preds = %608
%619 = add nsw i32 %32, 1
%620 = call i32 @DoArithmEval(i8* %0, i32 %619, i32 %49, i32* %7)
%621 = icmp eq i32 %620, 0
br i1 %621, label %758, label %622
622: ; preds = %618
%623 = load i32, i32* %7
%624 = icmp eq i32 %623, 0
%625 = zext i1 %624 to i32
store i32 %625, i32* %3
br label %758
626: ; preds = %608
%627 = add nsw i32 %32, 1
%628 = call i32 @DoArithmEval(i8* %0, i32 %627, i32 %49, i32* %7)
%629 = icmp eq i32 %628, 0
br i1 %629, label %758, label %630
630: ; preds = %626
%631 = load i32, i32* %7
%632 = sub nsw i32 0, %631
store i32 %632, i32* %3
br label %758
633: ; preds = %608
%634 = call i32 @strncmp(i8* %609, i8* dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.17, i64 0, i64 0), i64 7)
%635 = icmp eq i32 %634, 0
br i1 %635, label %636, label %645
636: ; preds = %633
%637 = add nsw i32 %49, -1
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds i8, i8* %0, i64 %638
%640 = load i8, i8* %639
%641 = icmp eq i8 %640, 41
br i1 %641, label %642, label %758
642: ; preds = %636
%643 = sub i32 -8, %32
%644 = add i32 %643, %49
store i32 %644, i32* %3
br label %758
645: ; preds = %633
%646 = call i32 @strncmp(i8* %609, i8* dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0), i64 7)
%647 = icmp eq i32 %646, 0
br i1 %647, label %648, label %738
648: ; preds = %645
%649 = add i32 %32, 7
%650 = icmp sgt i32 %649, %49
br i1 %650, label %658, label %651
651: ; preds = %648
%652 = sext i32 %49 to i64
%653 = getelementptr inbounds i8, i8* %0, i64 %652
%654 = load i8, i8* %653
%655 = icmp eq i8 %654, 0
%656 = sext i1 %655 to i32
%657 = add nsw i32 %49, %656
br label %658
658: ; preds = %651, %648
%659 = phi i32 [ %49, %648 ], [ %657, %651 ]
%660 = icmp sgt i32 %649, %659
br i1 %660, label %677, label %661
661: ; preds = %658
%662 = sext i32 %649 to i64
%663 = add i32 %659, 1
br label %664
664: ; preds = %661, %671
%665 = phi i64 [ %662, %661 ], [ %672, %671 ]
%666 = getelementptr inbounds i8, i8* %0, i64 %665
%667 = load i8, i8* %666
%668 = sext i8 %667 to i32
%669 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %668)
%670 = icmp eq i32 %669, 0
br i1 %670, label %675, label %671
671: ; preds = %664
%672 = add nsw i64 %665, 1
%673 = trunc i64 %672 to i32
%674 = icmp eq i32 %663, %673
br i1 %674, label %677, label %664
675: ; preds = %664
%676 = trunc i64 %665 to i32
br label %677
677: ; preds = %671, %675, %658
%678 = phi i32 [ %649, %658 ], [ %676, %675 ], [ %663, %671 ]
%679 = icmp sgt i32 %678, %659
br i1 %679, label %696, label %680
680: ; preds = %677
%681 = sext i32 %659 to i64
%682 = sext i32 %678 to i64
%683 = add i32 %678, -1
br label %684
684: ; preds = %680, %691
%685 = phi i64 [ %681, %680 ], [ %692, %691 ]
%686 = getelementptr inbounds i8, i8* %0, i64 %685
%687 = load i8, i8* %686
%688 = sext i8 %687 to i32
%689 = call i32 (i32, ...) bitcast (i32 (...)* @iswhite to i32 (i32, ...)*)(i32 %688)
%690 = icmp eq i32 %689, 0
br i1 %690, label %694, label %691
691: ; preds = %684
%692 = add nsw i64 %685, -1
%693 = icmp sgt i64 %685, %682
br i1 %693, label %684, label %696
694: ; preds = %684
%695 = trunc i64 %685 to i32
br label %696
696: ; preds = %691, %694, %677
%697 = phi i32 [ %659, %677 ], [ %695, %694 ], [ %683, %691 ]
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds i8, i8* %0, i64 %698
%700 = load i8, i8* %699
%701 = icmp eq i8 %700, 41
br i1 %701, label %704, label %702
702: ; preds = %696
%703 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.19, i64 0, i64 0))
br label %706
704: ; preds = %696
%705 = add nsw i32 %697, -1
br label %706
706: ; preds = %704, %702
%707 = phi i32 [ %697, %702 ], [ %705, %704 ]
%708 = sext i32 %678 to i64
%709 = getelementptr inbounds i8, i8* %0, i64 %708
%710 = load i8, i8* %709
switch i8 %710, label %713 [
i8 34, label %711
i8 60, label %711
]
711: ; preds = %706, %706
%712 = add nsw i32 %678, 1
br label %713
713: ; preds = %706, %711
%714 = phi i32 [ %712, %711 ], [ %678, %706 ]
%715 = sext i32 %707 to i64
%716 = getelementptr inbounds i8, i8* %0, i64 %715
%717 = load i8, i8* %716
switch i8 %717, label %720 [
i8 34, label %718
i8 62, label %718
]
718: ; preds = %713, %713
%719 = add nsw i32 %707, -1
br label %720
720: ; preds = %713, %718
%721 = phi i32 [ %719, %718 ], [ %707, %713 ]
%722 = icmp slt i32 %721, %714
br i1 %722, label %723, label %725
723: ; preds = %720
%724 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.20, i64 0, i64 0))
br label %725
725: ; preds = %723, %720
%726 = sub nsw i32 %721, %714
%727 = add nsw i32 %726, 2
%728 = sext i32 %727 to i64
%729 = call i8* @malloc(i64 %728)
%730 = sext i32 %714 to i64
%731 = getelementptr inbounds i8, i8* %0, i64 %730
%732 = add nsw i32 %726, 1
%733 = sext i32 %732 to i64
%734 = getelementptr inbounds i8, i8* %729, i64 %733
store i8 0, i8* %734
%735 = call i32 (i8*, ...) bitcast (i32 (...)* @checkAbsOrCurrentDir to i32 (i8*, ...)*)(i8* %729)
%736 = icmp ne i32 %735, 0
%737 = zext i1 %736 to i32
store i32 %737, i32* %3
br label %758
738: ; preds = %645
%739 = icmp eq i8 %610, 40
br i1 %739, label %740, label %749
740: ; preds = %738
%741 = add nsw i32 %49, -1
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds i8, i8* %0, i64 %742
%744 = load i8, i8* %743
%745 = icmp eq i8 %744, 41
br i1 %745, label %746, label %758
746: ; preds = %740
%747 = add nsw i32 %32, 1
%748 = call i32 @DoArithmEval(i8* %0, i32 %747, i32 %741, i32* %3)
br label %758
749: ; preds = %738
%750 = sext i32 %49 to i64
%751 = getelementptr inbounds i8, i8* %0, i64 %750
%752 = load i8, i8* %751
store i8 0, i8* %751
%753 = call i64 @strtol(i8* %609, i8** %9, i32 0)
%754 = trunc i64 %753 to i32
store i32 %754, i32* %3
store i8 %752, i8* %751
%755 = load i8*, i8** %9
%756 = icmp eq i8* %755, %751
%757 = zext i1 %756 to i32
br label %758
758: ; preds = %740, %636, %626, %618, %611, %590, %594, %569, %573, %554, %558, %540, %543, %522, %526, %251, %243, %242, %189, %181, %180, %120, %124, %105, %109, %90, %94, %72, %76, %54, %58, %48, %749, %746, %725, %642, %630, %622, %615, %604, %583, %562, %547, %530, %516, %450, %384, %319, %128, %113, %98, %80, %62
%759 = phi i32 [ 1, %62 ], [ 1, %80 ], [ 1, %98 ], [ 1, %113 ], [ 1, %128 ], [ 1, %319 ], [ 1, %384 ], [ 1, %450 ], [ 1, %516 ], [ 1, %530 ], [ 1, %547 ], [ 1, %562 ], [ 1, %583 ], [ 1, %604 ], [ 1, %615 ], [ 1, %622 ], [ 1, %630 ], [ 1, %642 ], [ 1, %725 ], [ %748, %746 ], [ %757, %749 ], [ 0, %48 ], [ 0, %58 ], [ 0, %54 ], [ 0, %76 ], [ 0, %72 ], [ 0, %94 ], [ 0, %90 ], [ 0, %109 ], [ 0, %105 ], [ 0, %124 ], [ 0, %120 ], [ 1, %180 ], [ 1, %181 ], [ 1, %189 ], [ 1, %242 ], [ 1, %243 ], [ 1, %251 ], [ 0, %526 ], [ 0, %522 ], [ 0, %543 ], [ 0, %540 ], [ 0, %558 ], [ 0, %554 ], [ 0, %573 ], [ 0, %569 ], [ 0, %594 ], [ 0, %590 ], [ 0, %611 ], [ 0, %618 ], [ 0, %626 ], [ 0, %636 ], [ 0, %740 ]
ret i32 %759
}