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


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,-0x51(%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,-0x51(%rbp)
mov    -0x51(%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,-0x52(%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,-0x52(%rbp)
mov    -0x52(%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    25da <DoArithmEval+0x144a>
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   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     12fe <DoArithmEval+0x16e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%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    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    12cb <DoArithmEval+0x13b>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x53(%rbp)
jne    12e4 <DoArithmEval+0x154>
cmpl   $0x0,-0x30(%rbp)
setne  %al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
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   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     139e <DoArithmEval+0x20e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%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    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    136b <DoArithmEval+0x1db>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x54(%rbp)
je     1384 <DoArithmEval+0x1f4>
cmpl   $0x0,-0x30(%rbp)
setne  %al
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
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   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1423 <DoArithmEval+0x293>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%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    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    140b <DoArithmEval+0x27b>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x2c(%rbp),%ecx
or     -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
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   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     14a8 <DoArithmEval+0x318>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%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    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1490 <DoArithmEval+0x300>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x2c(%rbp),%ecx
xor    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
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   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     152d <DoArithmEval+0x39d>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%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    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1515 <DoArithmEval+0x385>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x2c(%rbp),%ecx
and    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
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   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     16b0 <DoArithmEval+0x520>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%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    -0x30(%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,-0x55(%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,-0x55(%rbp)
mov    -0x55(%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,-0x56(%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,-0x56(%rbp)
mov    -0x56(%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   1040 <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    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
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   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1833 <DoArithmEval+0x6a3>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%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    -0x30(%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,-0x57(%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,-0x57(%rbp)
mov    -0x57(%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,-0x58(%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,-0x58(%rbp)
mov    -0x58(%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   1040 <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    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
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   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     19ea <DoArithmEval+0x85a>
lea    0x17ae(%rip),%rdi
mov    $0x0,%al
call   1050 <bug@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     18a2 <DoArithmEval+0x712>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    19ca <DoArithmEval+0x83a>
jmp    18a7 <DoArithmEval+0x717>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x59(%rbp)
jge    18d9 <DoArithmEval+0x749>
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    18e9 <DoArithmEval+0x759>
jmp    18f7 <DoArithmEval+0x767>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    18a7 <DoArithmEval+0x717>
jmp    18fc <DoArithmEval+0x76c>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x5a(%rbp)
jle    1929 <DoArithmEval+0x799>
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    1939 <DoArithmEval+0x7a9>
jmp    1947 <DoArithmEval+0x7b7>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    18fc <DoArithmEval+0x76c>
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
call   10b0 <strdup@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rdi
movslq -0x28(%rbp),%rax
add    %rax,%rdi
call   10b0 <strdup@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
xor    %edx,%edx
mov    $0x0,%al
call   1070 <fnmatch@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
jmp    19de <DoArithmEval+0x84e>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1640(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1ba0 <DoArithmEval+0xa10>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1a4b <DoArithmEval+0x8bb>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1b80 <DoArithmEval+0x9f0>
jmp    1a50 <DoArithmEval+0x8c0>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x5b(%rbp)
jge    1a82 <DoArithmEval+0x8f2>
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,-0x5b(%rbp)
mov    -0x5b(%rbp),%al
test   $0x1,%al
jne    1a92 <DoArithmEval+0x902>
jmp    1aa0 <DoArithmEval+0x910>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1a50 <DoArithmEval+0x8c0>
jmp    1aa5 <DoArithmEval+0x915>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x5c(%rbp)
jle    1ad2 <DoArithmEval+0x942>
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,-0x5c(%rbp)
mov    -0x5c(%rbp),%al
test   $0x1,%al
jne    1ae2 <DoArithmEval+0x952>
jmp    1af0 <DoArithmEval+0x960>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1aa5 <DoArithmEval+0x915>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    1b13 <DoArithmEval+0x983>
mov    -0x18(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
movslq -0x34(%rbp),%rdx
call   1040 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x5d(%rbp)
jg     1b6d <DoArithmEval+0x9dd>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x5e(%rbp)
jne    1b67 <DoArithmEval+0x9d7>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setge  %al
mov    %al,-0x5e(%rbp)
mov    -0x5e(%rbp),%al
mov    %al,-0x5d(%rbp)
mov    -0x5d(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1b94 <DoArithmEval+0xa04>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
setge  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x148d(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1d56 <DoArithmEval+0xbc6>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1c01 <DoArithmEval+0xa71>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1d36 <DoArithmEval+0xba6>
jmp    1c06 <DoArithmEval+0xa76>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x5f(%rbp)
jge    1c38 <DoArithmEval+0xaa8>
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,-0x5f(%rbp)
mov    -0x5f(%rbp),%al
test   $0x1,%al
jne    1c48 <DoArithmEval+0xab8>
jmp    1c56 <DoArithmEval+0xac6>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1c06 <DoArithmEval+0xa76>
jmp    1c5b <DoArithmEval+0xacb>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x60(%rbp)
jle    1c88 <DoArithmEval+0xaf8>
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,-0x60(%rbp)
mov    -0x60(%rbp),%al
test   $0x1,%al
jne    1c98 <DoArithmEval+0xb08>
jmp    1ca6 <DoArithmEval+0xb16>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1c5b <DoArithmEval+0xacb>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    1cc9 <DoArithmEval+0xb39>
mov    -0x18(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
movslq -0x34(%rbp),%rdx
call   1040 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x61(%rbp)
jg     1d23 <DoArithmEval+0xb93>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x62(%rbp)
jne    1d1d <DoArithmEval+0xb8d>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setg   %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1d4a <DoArithmEval+0xbba>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x12d9(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     1f0c <DoArithmEval+0xd7c>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1db7 <DoArithmEval+0xc27>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1eec <DoArithmEval+0xd5c>
jmp    1dbc <DoArithmEval+0xc2c>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x63(%rbp)
jge    1dee <DoArithmEval+0xc5e>
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,-0x63(%rbp)
mov    -0x63(%rbp),%al
test   $0x1,%al
jne    1dfe <DoArithmEval+0xc6e>
jmp    1e0c <DoArithmEval+0xc7c>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1dbc <DoArithmEval+0xc2c>
jmp    1e11 <DoArithmEval+0xc81>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x64(%rbp)
jle    1e3e <DoArithmEval+0xcae>
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,-0x64(%rbp)
mov    -0x64(%rbp),%al
test   $0x1,%al
jne    1e4e <DoArithmEval+0xcbe>
jmp    1e5c <DoArithmEval+0xccc>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1e11 <DoArithmEval+0xc81>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    1e7f <DoArithmEval+0xcef>
mov    -0x18(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
movslq -0x34(%rbp),%rdx
call   1040 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x65(%rbp)
jl     1ed9 <DoArithmEval+0xd49>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x66(%rbp)
jne    1ed3 <DoArithmEval+0xd43>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setle  %al
mov    %al,-0x66(%rbp)
mov    -0x66(%rbp),%al
mov    %al,-0x65(%rbp)
mov    -0x65(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1f00 <DoArithmEval+0xd70>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1126(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     20c2 <DoArithmEval+0xf32>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1f6d <DoArithmEval+0xddd>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    20a2 <DoArithmEval+0xf12>
jmp    1f72 <DoArithmEval+0xde2>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x67(%rbp)
jge    1fa4 <DoArithmEval+0xe14>
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,-0x67(%rbp)
mov    -0x67(%rbp),%al
test   $0x1,%al
jne    1fb4 <DoArithmEval+0xe24>
jmp    1fc2 <DoArithmEval+0xe32>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1f72 <DoArithmEval+0xde2>
jmp    1fc7 <DoArithmEval+0xe37>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x68(%rbp)
jle    1ff4 <DoArithmEval+0xe64>
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,-0x68(%rbp)
mov    -0x68(%rbp),%al
test   $0x1,%al
jne    2004 <DoArithmEval+0xe74>
jmp    2012 <DoArithmEval+0xe82>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1fc7 <DoArithmEval+0xe37>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    2035 <DoArithmEval+0xea5>
mov    -0x18(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
movslq -0x34(%rbp),%rdx
call   1040 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x69(%rbp)
jl     208f <DoArithmEval+0xeff>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x6a(%rbp)
jne    2089 <DoArithmEval+0xef9>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x6a(%rbp)
mov    -0x6a(%rbp),%al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    20b6 <DoArithmEval+0xf26>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xf72(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     2147 <DoArithmEval+0xfb7>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     2123 <DoArithmEval+0xf93>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    212f <DoArithmEval+0xf9f>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xeef(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     21dd <DoArithmEval+0x104d>
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     21d8 <DoArithmEval+0x1048>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     21b4 <DoArithmEval+0x1024>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    21c0 <DoArithmEval+0x1030>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x2c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
jmp    21dd <DoArithmEval+0x104d>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xe5b(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     2263 <DoArithmEval+0x10d3>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     223e <DoArithmEval+0x10ae>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    224a <DoArithmEval+0x10ba>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x2c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xdd7(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     2303 <DoArithmEval+0x1173>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     22c4 <DoArithmEval+0x1134>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    22d0 <DoArithmEval+0x1140>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
cmpl   $0x0,-0x30(%rbp)
jne    22e8 <DoArithmEval+0x1158>
lea    0xd6c(%rip),%rdi
mov    $0x0,%al
call   1050 <bug@plt>
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xd58(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
mov    $0x0,%al
call   10a0 <SpliceInfix@plt>
cmp    $0x0,%eax
je     23a1 <DoArithmEval+0x1211>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     2364 <DoArithmEval+0x11d4>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2370 <DoArithmEval+0x11e0>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
cmpl   $0x0,-0x30(%rbp)
jne    2388 <DoArithmEval+0x11f8>
lea    0xccc(%rip),%rdi
mov    $0x0,%al
call   1050 <bug@plt>
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %edx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7e,%eax
jne    23f9 <DoArithmEval+0x1269>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    23e1 <DoArithmEval+0x1251>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x2c(%rbp),%ecx
xor    $0xffffffff,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x21,%eax
jne    2459 <DoArithmEval+0x12c9>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2439 <DoArithmEval+0x12a9>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
cmpl   $0x0,-0x2c(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    24b0 <DoArithmEval+0x1320>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2499 <DoArithmEval+0x1309>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
xor    %ecx,%ecx
sub    -0x2c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
lea    0xbac(%rip),%rsi
mov    $0x7,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    251b <DoArithmEval+0x138b>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     24fb <DoArithmEval+0x136b>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
cltq
sub    $0x8,%rax
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    2577 <DoArithmEval+0x13e7>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     2556 <DoArithmEval+0x13c6>
movl   $0x0,-0x4(%rbp)
jmp    25da <DoArithmEval+0x144a>
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    25da <DoArithmEval+0x144a>
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   1080 <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,%ebp
mov    %esi,%r13d
mov    %rdi,%r15
cmp    %edx,%esi
mov    %rcx,0x20(%rsp)
jge    11de <DoArithmEval+0x4e>
movslq %r13d,%rbx
add    %r15,%rbx
nopl   0x0(%rax,%rax,1)
movsbl (%rbx),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
test   %eax,%eax
je     11de <DoArithmEval+0x4e>
add    $0x1,%r13d
add    $0x1,%rbx
cmp    %r13d,%ebp
jne    11c0 <DoArithmEval+0x30>
mov    %ebp,%r13d
movslq %ebp,%rbx
movslq %r13d,%r12
cmp    %ebp,%r12d
mov    %ebp,%r14d
cmovl  %r13d,%r14d
add    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r12,%rbx
jle    121f <DoArithmEval+0x8f>
movsbl -0x1(%r15,%rbx,1),%edi
add    $0xffffffffffffffff,%rbx
xor    %eax,%eax
call   1090 <isWhite@plt>
add    $0xffffffff,%ebp
test   %eax,%eax
jne    1200 <DoArithmEval+0x70>
jmp    1222 <DoArithmEval+0x92>
mov    %r14d,%ebp
xor    %ebx,%ebx
mov    %ebp,%r14d
sub    %r13d,%r14d
jne    123d <DoArithmEval+0xad>
mov    %ebx,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xdbc(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     12b0 <DoArithmEval+0x120>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x10(%rsp),%eax
xor    %ecx,%ecx
or     0xc(%rsp),%eax
setne  %cl
mov    0x20(%rsp),%rax
mov    %ecx,(%rax)
mov    $0x1,%ebx
jmp    122c <DoArithmEval+0x9c>
lea    0xd4c(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1327 <DoArithmEval+0x197>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
cmpl   $0x0,0x10(%rsp)
setne  %al
cmpl   $0x0,0xc(%rsp)
setne  %cl
and    %al,%cl
movzbl %cl,%eax
jmp    145d <DoArithmEval+0x2cd>
lea    0xcd3(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1391 <DoArithmEval+0x201>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0xc(%rsp),%eax
or     0x10(%rsp),%eax
jmp    145d <DoArithmEval+0x2cd>
lea    0xc6e(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     13f8 <DoArithmEval+0x268>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0xc(%rsp),%eax
xor    0x10(%rsp),%eax
jmp    145d <DoArithmEval+0x2cd>
lea    0xc05(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     146e <DoArithmEval+0x2de>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0xc(%rsp),%eax
and    0x10(%rsp),%eax
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
mov    $0x1,%ebx
jmp    122c <DoArithmEval+0x9c>
lea    0xb93(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1556 <DoArithmEval+0x3c6>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     14d4 <DoArithmEval+0x344>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     14d4 <DoArithmEval+0x344>
mov    0x10(%rsp),%eax
xor    %ecx,%ecx
cmp    0xc(%rsp),%eax
jmp    129c <DoArithmEval+0x10c>
mov    0x4(%rsp),%eax
cmp    %eax,%r13d
jge    1500 <DoArithmEval+0x370>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
test   %eax,%eax
je     1500 <DoArithmEval+0x370>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r13d
jl     14dd <DoArithmEval+0x34d>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebp
jle    152a <DoArithmEval+0x39a>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     152a <DoArithmEval+0x39a>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebp
jg     1508 <DoArithmEval+0x378>
movslq 0x4(%rsp),%rdx
sub    %r12,%rdx
sub    %ecx,%ebp
cmp    %ebp,%edx
jne    1636 <DoArithmEval+0x4a6>
add    %r15,%r12
movslq %ecx,%rsi
add    %r15,%rsi
mov    %r12,%rdi
call   1040 <strncmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
jmp    129c <DoArithmEval+0x10c>
lea    0xaae(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     164b <DoArithmEval+0x4bb>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     15b1 <DoArithmEval+0x421>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
jne    16b0 <DoArithmEval+0x520>
mov    0x4(%rsp),%eax
cmp    %eax,%r13d
jge    15dd <DoArithmEval+0x44d>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
test   %eax,%eax
je     15dd <DoArithmEval+0x44d>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r13d
jl     15ba <DoArithmEval+0x42a>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebp
jle    1607 <DoArithmEval+0x477>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1607 <DoArithmEval+0x477>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebp
jg     15e5 <DoArithmEval+0x455>
movslq 0x4(%rsp),%rdx
sub    %r12,%rdx
sub    %ecx,%ebp
cmp    %ebp,%edx
jne    16c2 <DoArithmEval+0x532>
add    %r15,%r12
movslq %ecx,%rsi
add    %r15,%rsi
mov    %r12,%rdi
call   1040 <strncmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
sete   %cl
jmp    129f <DoArithmEval+0x10f>
mov    0x20(%rsp),%rax
movl   $0x1,(%rax)
mov    $0x1,%ebx
jmp    122c <DoArithmEval+0x9c>
lea    0x9bc(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1799 <DoArithmEval+0x609>
lea    0x997(%rip),%rdi
xor    %eax,%eax
call   1050 <bug@plt>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     16d7 <DoArithmEval+0x547>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     16d7 <DoArithmEval+0x547>
mov    0x10(%rsp),%eax
xor    %ecx,%ecx
cmp    0xc(%rsp),%eax
sete   %cl
jmp    129f <DoArithmEval+0x10f>
mov    0x20(%rsp),%rax
movl   $0x0,(%rax)
mov    $0x1,%ebx
jmp    122c <DoArithmEval+0x9c>
mov    0x4(%rsp),%eax
cmp    %eax,%r13d
jge    1703 <DoArithmEval+0x573>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
test   %eax,%eax
je     1703 <DoArithmEval+0x573>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r13d
jl     16e0 <DoArithmEval+0x550>
mov    0x8(%rsp),%ebx
cmp    %ebx,%ebp
jle    172d <DoArithmEval+0x59d>
movslq %ebx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
mov    0x8(%rsp),%ebx
test   %eax,%eax
je     172d <DoArithmEval+0x59d>
add    $0x1,%ebx
mov    %ebx,0x8(%rsp)
cmp    %ebx,%ebp
jg     170b <DoArithmEval+0x57b>
lea    (%r15,%r12,1),%rdi
call   10b0 <strdup@plt>
mov    %rax,%r13
movslq 0x4(%rsp),%rax
sub    %r12,%rax
movb   $0x0,0x0(%r13,%rax,1)
movslq %ebx,%rbx
add    %rbx,%r15
mov    %r15,%rdi
call   10b0 <strdup@plt>
mov    %rax,%r14
sub    %ebx,%ebp
movslq %ebp,%rax
movb   $0x0,(%r14,%rax,1)
mov    %r14,%rdi
mov    %r13,%rsi
xor    %edx,%edx
xor    %eax,%eax
call   1070 <fnmatch@plt>
xor    %ecx,%ecx
test   %eax,%eax
sete   %cl
mov    0x20(%rsp),%rax
mov    %ecx,(%rax)
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    $0x1,%ebx
jmp    122c <DoArithmEval+0x9c>
lea    0x89b(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1895 <DoArithmEval+0x705>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1800 <DoArithmEval+0x670>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1800 <DoArithmEval+0x670>
mov    0x10(%rsp),%eax
cmp    0xc(%rsp),%eax
setge  %cl
jmp    131f <DoArithmEval+0x18f>
mov    0x4(%rsp),%eax
cmp    %eax,%r13d
jge    182c <DoArithmEval+0x69c>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
test   %eax,%eax
je     182c <DoArithmEval+0x69c>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r13d
jl     1809 <DoArithmEval+0x679>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebp
jle    1856 <DoArithmEval+0x6c6>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1856 <DoArithmEval+0x6c6>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebp
jg     1834 <DoArithmEval+0x6a4>
mov    0x4(%rsp),%ebx
sub    %r13d,%ebx
sub    %ecx,%ebp
cmp    %ebp,%ebx
mov    %ebx,%eax
cmovg  %ebp,%eax
add    %r15,%r12
movslq %ecx,%rsi
add    %r15,%rsi
movslq %eax,%rdx
mov    %r12,%rdi
call   1040 <strncmp@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%cl
test   %eax,%eax
jg     131f <DoArithmEval+0x18f>
sete   %al
cmp    %ebp,%ebx
setge  %cl
jmp    131d <DoArithmEval+0x18d>
lea    0x7a2(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1995 <DoArithmEval+0x805>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     18fc <DoArithmEval+0x76c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     18fc <DoArithmEval+0x76c>
mov    0x10(%rsp),%eax
cmp    0xc(%rsp),%eax
setg   %cl
jmp    131f <DoArithmEval+0x18f>
mov    0x4(%rsp),%eax
cmp    %eax,%r13d
jge    1928 <DoArithmEval+0x798>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
test   %eax,%eax
je     1928 <DoArithmEval+0x798>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r13d
jl     1905 <DoArithmEval+0x775>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebp
jle    1952 <DoArithmEval+0x7c2>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1952 <DoArithmEval+0x7c2>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebp
jg     1930 <DoArithmEval+0x7a0>
mov    0x4(%rsp),%ebx
sub    %r13d,%ebx
sub    %ecx,%ebp
cmp    %ebp,%ebx
mov    %ebx,%eax
cmovg  %ebp,%eax
add    %r15,%r12
movslq %ecx,%rsi
add    %r15,%rsi
movslq %eax,%rdx
mov    %r12,%rdi
call   1040 <strncmp@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%cl
test   %eax,%eax
jg     131f <DoArithmEval+0x18f>
cmp    %ebp,%ebx
setg   %dl
test   %eax,%eax
sete   %cl
and    %dl,%cl
jmp    131f <DoArithmEval+0x18f>
lea    0x6a4(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1a91 <DoArithmEval+0x901>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     19fc <DoArithmEval+0x86c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     19fc <DoArithmEval+0x86c>
mov    0x10(%rsp),%eax
cmp    0xc(%rsp),%eax
setle  %cl
jmp    131f <DoArithmEval+0x18f>
mov    0x4(%rsp),%eax
cmp    %eax,%r13d
jge    1a28 <DoArithmEval+0x898>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
test   %eax,%eax
je     1a28 <DoArithmEval+0x898>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r13d
jl     1a05 <DoArithmEval+0x875>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebp
jle    1a52 <DoArithmEval+0x8c2>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1a52 <DoArithmEval+0x8c2>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebp
jg     1a30 <DoArithmEval+0x8a0>
mov    0x4(%rsp),%ebx
sub    %r13d,%ebx
sub    %ecx,%ebp
cmp    %ebp,%ebx
mov    %ebx,%eax
cmovg  %ebp,%eax
add    %r15,%r12
movslq %ecx,%rsi
add    %r15,%rsi
movslq %eax,%rdx
mov    %r12,%rdi
call   1040 <strncmp@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%cl
test   %eax,%eax
js     131f <DoArithmEval+0x18f>
sete   %al
cmp    %ebp,%ebx
setle  %cl
jmp    131d <DoArithmEval+0x18d>
lea    0x5ab(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1b8d <DoArithmEval+0x9fd>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1af8 <DoArithmEval+0x968>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1af8 <DoArithmEval+0x968>
mov    0x10(%rsp),%eax
cmp    0xc(%rsp),%eax
setl   %cl
jmp    131f <DoArithmEval+0x18f>
mov    0x4(%rsp),%eax
cmp    %eax,%r13d
jge    1b24 <DoArithmEval+0x994>
cltq
movsbl -0x1(%rax,%r15,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
test   %eax,%eax
je     1b24 <DoArithmEval+0x994>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
cmp    %eax,%r13d
jl     1b01 <DoArithmEval+0x971>
mov    0x8(%rsp),%ecx
cmp    %ecx,%ebp
jle    1b4e <DoArithmEval+0x9be>
movslq %ecx,%rax
movsbl (%r15,%rax,1),%edi
xor    %eax,%eax
call   1090 <isWhite@plt>
mov    0x8(%rsp),%ecx
test   %eax,%eax
je     1b4e <DoArithmEval+0x9be>
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
cmp    %ecx,%ebp
jg     1b2c <DoArithmEval+0x99c>
mov    0x4(%rsp),%ebx
sub    %r13d,%ebx
sub    %ecx,%ebp
cmp    %ebp,%ebx
mov    %ebx,%eax
cmovg  %ebp,%eax
add    %r15,%r12
movslq %ecx,%rsi
add    %r15,%rsi
movslq %eax,%rdx
mov    %r12,%rdi
call   1040 <strncmp@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%cl
test   %eax,%eax
js     131f <DoArithmEval+0x18f>
sete   %al
cmp    %ebp,%ebx
setl   %cl
jmp    131d <DoArithmEval+0x18d>
lea    0x4b1(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1bf7 <DoArithmEval+0xa67>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0xc(%rsp),%eax
add    0x10(%rsp),%eax
jmp    145d <DoArithmEval+0x2cd>
lea    0x449(%rip),%rcx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1c24 <DoArithmEval+0xa94>
mov    0x4(%rsp),%edx
cmp    %r13d,%edx
jne    1c93 <DoArithmEval+0xb03>
lea    0x41e(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1cd5 <DoArithmEval+0xb45>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0xc(%rsp),%eax
imul   0x10(%rsp),%eax
jmp    145d <DoArithmEval+0x2cd>
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
xor    %ebx,%ebx
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x10(%rsp),%eax
sub    0xc(%rsp),%eax
jmp    145d <DoArithmEval+0x2cd>
lea    0x36f(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1d58 <DoArithmEval+0xbc8>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jne    1d4c <DoArithmEval+0xbbc>
lea    0x30c(%rip),%rdi
xor    %eax,%eax
call   1050 <bug@plt>
mov    0xc(%rsp),%ecx
mov    0x10(%rsp),%eax
cltd
idiv   %ecx
jmp    145d <DoArithmEval+0x2cd>
lea    0x30d(%rip),%rcx
xor    %ebx,%ebx
lea    0x4(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <SpliceInfix@plt>
test   %eax,%eax
je     1de7 <DoArithmEval+0xc57>
mov    0x4(%rsp),%edx
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x8(%rsp),%esi
lea    0xc(%rsp),%rcx
mov    %r15,%rdi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jne    1dcf <DoArithmEval+0xc3f>
lea    0x289(%rip),%rdi
xor    %eax,%eax
call   1050 <bug@plt>
mov    0xc(%rsp),%ecx
mov    0x10(%rsp),%eax
cltd
idiv   %ecx
mov    0x20(%rsp),%rax
mov    %edx,(%rax)
mov    $0x1,%ebx
jmp    122c <DoArithmEval+0x9c>
mov    (%r15,%r12,1),%al
mov    %al,0x1f(%rsp)
cmp    $0x21,%al
je     1e2a <DoArithmEval+0xc9a>
cmpb   $0x2d,0x1f(%rsp)
je     1e57 <DoArithmEval+0xcc7>
cmpb   $0x7e,0x1f(%rsp)
jne    1e80 <DoArithmEval+0xcf0>
add    $0x1,%r13d
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
mov    0x10(%rsp),%eax
not    %eax
jmp    145d <DoArithmEval+0x2cd>
add    $0x1,%r13d
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
xor    %eax,%eax
cmpl   $0x0,0x10(%rsp)
sete   %al
jmp    145d <DoArithmEval+0x2cd>
add    $0x1,%r13d
lea    0x10(%rsp),%rcx
mov    %r15,%rdi
mov    %r13d,%esi
mov    %ebp,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     122c <DoArithmEval+0x9c>
xor    %eax,%eax
sub    0x10(%rsp),%eax
jmp    145d <DoArithmEval+0x2cd>
add    %r15,%r12
lea    0x1e4(%rip),%rsi
mov    $0x7,%edx
mov    %r12,%rdi
call   1040 <strncmp@plt>
test   %eax,%eax
je     1ed0 <DoArithmEval+0xd40>
cmpb   $0x28,0x1f(%rsp)
jne    1ef5 <DoArithmEval+0xd65>
movslq %ebp,%rdx
cmpb   $0x29,-0x1(%r15,%rdx,1)
jne    122c <DoArithmEval+0x9c>
add    $0xffffffffffffffff,%rdx
add    $0x1,%r13d
mov    %r15,%rdi
mov    %r13d,%esi
mov    0x20(%rsp),%rcx
call   1060 <DoArithmEval@plt>
mov    %eax,%ebx
jmp    122c <DoArithmEval+0x9c>
movslq %ebp,%rax
cmpb   $0x29,-0x1(%rax,%r15,1)
jne    122c <DoArithmEval+0x9c>
add    $0xfffffff8,%r14d
mov    0x20(%rsp),%rax
mov    %r14d,(%rax)
mov    $0x1,%ebx
jmp    122c <DoArithmEval+0x9c>
movslq %ebp,%rbx
lea    (%r15,%rbx,1),%rbp
mov    (%r15,%rbx,1),%r14b
movb   $0x0,(%r15,%rbx,1)
lea    0x10(%rsp),%rsi
mov    %r12,%rdi
xor    %edx,%edx
call   1080 <strtol@plt>
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
mov    %r14b,(%r15,%rbx,1)
xor    %ebx,%ebx
cmp    %rbp,0x10(%rsp)
sete   %bl
jmp    122c <DoArithmEval+0x9c>

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

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 = [42 x i8] c"globbing support has not been compiled in\00"
@.str.9 = [3 x i8] c">=\00"
@.str.10 = [2 x i8] c">\00"
@.str.11 = [3 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 = [2 x i8] c"*\00"
@.str.16 = [2 x i8] c"/\00"
@.str.17 = [31 x i8] c"Division by zero in expression\00"
@.str.18 = [2 x i8] c"%\00"
@.str.19 = [8 x i8] c"length(\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 %730, 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 %730, 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 %730, 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 %730
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 %730, 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 %730, 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 %730
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 %730, 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 %730, 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 %730
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 %730, 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 %730, 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 %730
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 %730, 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 %730, 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 %730
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 %730
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 %730
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 %730
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 %730
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 %730
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 %730
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 %321, label %259
259: ; preds = %256
%260 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.8, i64 0, i64 0))
%261 = load i32, i32* %5
%262 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %261, i32* %7)
%263 = icmp eq i32 %262, 0
br i1 %263, label %268, label %264
264: ; preds = %259
%265 = load i32, i32* %6
%266 = call i32 @DoArithmEval(i8* %0, i32 %265, i32 %49, i32* %8)
%267 = icmp eq i32 %266, 0
br i1 %267, label %268, label %316
268: ; preds = %264, %259
%269 = load i32, i32* %5
%270 = icmp slt i32 %32, %269
br i1 %270, label %271, label %284
271: ; preds = %268, %280
%272 = phi i32 [ %282, %280 ], [ %269, %268 ]
%273 = add nsw i32 %272, -1
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds i8, i8* %0, i64 %274
%276 = load i8, i8* %275
%277 = sext i8 %276 to i32
%278 = call i32 (i32, ...) bitcast (i32 (...)* @isWhite to i32 (i32, ...)*)(i32 %277)
%279 = icmp eq i32 %278, 0
br i1 %279, label %284, label %280
280: ; preds = %271
%281 = load i32, i32* %5
%282 = add nsw i32 %281, -1
store i32 %282, i32* %5
%283 = icmp slt i32 %32, %282
br i1 %283, label %271, label %284
284: ; preds = %271, %280, %268
%285 = load i32, i32* %6
%286 = icmp sgt i32 %49, %285
br i1 %286, label %287, label %299
287: ; preds = %284, %296
%288 = phi i32 [ %297, %296 ], [ %285, %284 ]
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i8, i8* %0, i64 %289
%291 = load i8, i8* %290
%292 = sext i8 %291 to i32
%293 = call i32 (i32, ...) bitcast (i32 (...)* @isWhite to i32 (i32, ...)*)(i32 %292)
%294 = icmp eq i32 %293, 0
%295 = load i32, i32* %6
br i1 %294, label %299, label %296
296: ; preds = %287
%297 = add nsw i32 %295, 1
store i32 %297, i32* %6
%298 = icmp sgt i32 %49, %297
br i1 %298, label %287, label %299
299: ; preds = %296, %287, %284
%300 = phi i32 [ %285, %284 ], [ %295, %287 ], [ %297, %296 ]
%301 = getelementptr inbounds i8, i8* %0, i64 %34
%302 = call i8* @strdup(i8* %301)
%303 = load i32, i32* %5
%304 = sub nsw i32 %303, %32
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds i8, i8* %302, i64 %305
store i8 0, i8* %306
%307 = sext i32 %300 to i64
%308 = getelementptr inbounds i8, i8* %0, i64 %307
%309 = call i8* @strdup(i8* %308)
%310 = sub nsw i32 %49, %300
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i8, i8* %309, i64 %311
store i8 0, i8* %312
%313 = call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @fnmatch to i32 (i8*, i8*, i32, ...)*)(i8* %309, i8* %302, i32 0)
%314 = icmp eq i32 %313, 0
%315 = zext i1 %314 to i32
store i32 %315, i32* %3
br label %730
316: ; preds = %264
%317 = load i32, i32* %7
%318 = load i32, i32* %8
%319 = icmp eq i32 %317, %318
%320 = zext i1 %319 to i32
store i32 %320, i32* %3
br label %730
321: ; preds = %256
%322 = 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)
%323 = icmp eq i32 %322, 0
br i1 %323, label %387, label %324
324: ; preds = %321
%325 = load i32, i32* %5
%326 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %325, i32* %7)
%327 = icmp eq i32 %326, 0
br i1 %327, label %332, label %328
328: ; preds = %324
%329 = load i32, i32* %6
%330 = call i32 @DoArithmEval(i8* %0, i32 %329, i32 %49, i32* %8)
%331 = icmp eq i32 %330, 0
br i1 %331, label %332, label %380
332: ; preds = %328, %324
%333 = load i32, i32* %5
%334 = icmp slt i32 %32, %333
br i1 %334, label %335, label %348
335: ; preds = %332, %344
%336 = phi i32 [ %346, %344 ], [ %333, %332 ]
%337 = add nsw i32 %336, -1
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i8, i8* %0, i64 %338
%340 = load i8, i8* %339
%341 = sext i8 %340 to i32
%342 = call i32 (i32, ...) bitcast (i32 (...)* @isWhite to i32 (i32, ...)*)(i32 %341)
%343 = icmp eq i32 %342, 0
br i1 %343, label %348, label %344
344: ; preds = %335
%345 = load i32, i32* %5
%346 = add nsw i32 %345, -1
store i32 %346, i32* %5
%347 = icmp slt i32 %32, %346
br i1 %347, label %335, label %348
348: ; preds = %335, %344, %332
%349 = load i32, i32* %6
%350 = icmp sgt i32 %49, %349
br i1 %350, label %351, label %363
351: ; preds = %348, %360
%352 = phi i32 [ %361, %360 ], [ %349, %348 ]
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds i8, i8* %0, i64 %353
%355 = load i8, i8* %354
%356 = sext i8 %355 to i32
%357 = call i32 (i32, ...) bitcast (i32 (...)* @isWhite to i32 (i32, ...)*)(i32 %356)
%358 = icmp eq i32 %357, 0
%359 = load i32, i32* %6
br i1 %358, label %363, label %360
360: ; preds = %351
%361 = add nsw i32 %359, 1
store i32 %361, i32* %6
%362 = icmp sgt i32 %49, %361
br i1 %362, label %351, label %363
363: ; preds = %360, %351, %348
%364 = phi i32 [ %349, %348 ], [ %359, %351 ], [ %361, %360 ]
%365 = load i32, i32* %5
%366 = sub nsw i32 %365, %32
%367 = sub nsw i32 %49, %364
%368 = icmp sgt i32 %366, %367
%369 = select i1 %368, i32 %367, i32 %366
%370 = getelementptr inbounds i8, i8* %0, i64 %34
%371 = sext i32 %364 to i64
%372 = getelementptr inbounds i8, i8* %0, i64 %371
%373 = sext i32 %369 to i64
%374 = call i32 @strncmp(i8* %370, i8* %372, i64 %373)
store i32 %374, i32* %7
%375 = icmp sgt i32 %374, 0
br i1 %375, label %384, label %376
376: ; preds = %363
%377 = icmp eq i32 %374, 0
%378 = icmp sge i32 %366, %367
%379 = select i1 %377, i1 %378, i1 false
br label %384
380: ; preds = %328
%381 = load i32, i32* %7
%382 = load i32, i32* %8
%383 = icmp sge i32 %381, %382
br label %384
384: ; preds = %376, %363, %380
%385 = phi i1 [ %383, %380 ], [ true, %363 ], [ %379, %376 ]
%386 = zext i1 %385 to i32
store i32 %386, i32* %3
br label %730
387: ; preds = %321
%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 ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0), i32* %5, i32* %6)
%389 = icmp eq i32 %388, 0
br i1 %389, label %452, 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 %445
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 sgt i32 %440, 0
br i1 %441, label %449, label %442
442: ; preds = %429
%443 = icmp eq i32 %440, 0
%444 = select i1 %443, i1 %434, i1 false
br label %449
445: ; preds = %394
%446 = load i32, i32* %7
%447 = load i32, i32* %8
%448 = icmp sgt i32 %446, %447
br label %449
449: ; preds = %442, %429, %445
%450 = phi i1 [ %448, %445 ], [ true, %429 ], [ %444, %442 ]
%451 = zext i1 %450 to i32
store i32 %451, i32* %3
br label %730
452: ; preds = %387
%453 = 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.11, i64 0, i64 0), i32* %5, i32* %6)
%454 = icmp eq i32 %453, 0
br i1 %454, label %518, label %455
455: ; preds = %452
%456 = load i32, i32* %5
%457 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %456, i32* %7)
%458 = icmp eq i32 %457, 0
br i1 %458, label %463, label %459
459: ; preds = %455
%460 = load i32, i32* %6
%461 = call i32 @DoArithmEval(i8* %0, i32 %460, i32 %49, i32* %8)
%462 = icmp eq i32 %461, 0
br i1 %462, label %463, label %511
463: ; preds = %459, %455
%464 = load i32, i32* %5
%465 = icmp slt i32 %32, %464
br i1 %465, label %466, label %479
466: ; preds = %463, %475
%467 = phi i32 [ %477, %475 ], [ %464, %463 ]
%468 = add nsw i32 %467, -1
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds i8, i8* %0, i64 %469
%471 = load i8, i8* %470
%472 = sext i8 %471 to i32
%473 = call i32 (i32, ...) bitcast (i32 (...)* @isWhite to i32 (i32, ...)*)(i32 %472)
%474 = icmp eq i32 %473, 0
br i1 %474, label %479, label %475
475: ; preds = %466
%476 = load i32, i32* %5
%477 = add nsw i32 %476, -1
store i32 %477, i32* %5
%478 = icmp slt i32 %32, %477
br i1 %478, label %466, label %479
479: ; preds = %466, %475, %463
%480 = load i32, i32* %6
%481 = icmp sgt i32 %49, %480
br i1 %481, label %482, label %494
482: ; preds = %479, %491
%483 = phi i32 [ %492, %491 ], [ %480, %479 ]
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds i8, i8* %0, i64 %484
%486 = load i8, i8* %485
%487 = sext i8 %486 to i32
%488 = call i32 (i32, ...) bitcast (i32 (...)* @isWhite to i32 (i32, ...)*)(i32 %487)
%489 = icmp eq i32 %488, 0
%490 = load i32, i32* %6
br i1 %489, label %494, label %491
491: ; preds = %482
%492 = add nsw i32 %490, 1
store i32 %492, i32* %6
%493 = icmp sgt i32 %49, %492
br i1 %493, label %482, label %494
494: ; preds = %491, %482, %479
%495 = phi i32 [ %480, %479 ], [ %490, %482 ], [ %492, %491 ]
%496 = load i32, i32* %5
%497 = sub nsw i32 %496, %32
%498 = sub nsw i32 %49, %495
%499 = icmp sgt i32 %497, %498
%500 = select i1 %499, i32 %498, i32 %497
%501 = getelementptr inbounds i8, i8* %0, i64 %34
%502 = sext i32 %495 to i64
%503 = getelementptr inbounds i8, i8* %0, i64 %502
%504 = sext i32 %500 to i64
%505 = call i32 @strncmp(i8* %501, i8* %503, i64 %504)
store i32 %505, i32* %7
%506 = icmp slt i32 %505, 0
br i1 %506, label %515, label %507
507: ; preds = %494
%508 = icmp eq i32 %505, 0
%509 = icmp sle i32 %497, %498
%510 = select i1 %508, i1 %509, i1 false
br label %515
511: ; preds = %459
%512 = load i32, i32* %7
%513 = load i32, i32* %8
%514 = icmp sle i32 %512, %513
br label %515
515: ; preds = %507, %494, %511
%516 = phi i1 [ %514, %511 ], [ true, %494 ], [ %510, %507 ]
%517 = zext i1 %516 to i32
store i32 %517, i32* %3
br label %730
518: ; preds = %452
%519 = 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)
%520 = icmp eq i32 %519, 0
br i1 %520, label %584, label %521
521: ; preds = %518
%522 = load i32, i32* %5
%523 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %522, i32* %7)
%524 = icmp eq i32 %523, 0
br i1 %524, label %529, label %525
525: ; preds = %521
%526 = load i32, i32* %6
%527 = call i32 @DoArithmEval(i8* %0, i32 %526, i32 %49, i32* %8)
%528 = icmp eq i32 %527, 0
br i1 %528, label %529, label %577
529: ; preds = %525, %521
%530 = load i32, i32* %5
%531 = icmp slt i32 %32, %530
br i1 %531, label %532, label %545
532: ; preds = %529, %541
%533 = phi i32 [ %543, %541 ], [ %530, %529 ]
%534 = add nsw i32 %533, -1
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds i8, i8* %0, i64 %535
%537 = load i8, i8* %536
%538 = sext i8 %537 to i32
%539 = call i32 (i32, ...) bitcast (i32 (...)* @isWhite to i32 (i32, ...)*)(i32 %538)
%540 = icmp eq i32 %539, 0
br i1 %540, label %545, label %541
541: ; preds = %532
%542 = load i32, i32* %5
%543 = add nsw i32 %542, -1
store i32 %543, i32* %5
%544 = icmp slt i32 %32, %543
br i1 %544, label %532, label %545
545: ; preds = %532, %541, %529
%546 = load i32, i32* %6
%547 = icmp sgt i32 %49, %546
br i1 %547, label %548, label %560
548: ; preds = %545, %557
%549 = phi i32 [ %558, %557 ], [ %546, %545 ]
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds i8, i8* %0, i64 %550
%552 = load i8, i8* %551
%553 = sext i8 %552 to i32
%554 = call i32 (i32, ...) bitcast (i32 (...)* @isWhite to i32 (i32, ...)*)(i32 %553)
%555 = icmp eq i32 %554, 0
%556 = load i32, i32* %6
br i1 %555, label %560, label %557
557: ; preds = %548
%558 = add nsw i32 %556, 1
store i32 %558, i32* %6
%559 = icmp sgt i32 %49, %558
br i1 %559, label %548, label %560
560: ; preds = %557, %548, %545
%561 = phi i32 [ %546, %545 ], [ %556, %548 ], [ %558, %557 ]
%562 = load i32, i32* %5
%563 = sub nsw i32 %562, %32
%564 = sub nsw i32 %49, %561
%565 = icmp sgt i32 %563, %564
%566 = select i1 %565, i32 %564, i32 %563
%567 = getelementptr inbounds i8, i8* %0, i64 %34
%568 = sext i32 %561 to i64
%569 = getelementptr inbounds i8, i8* %0, i64 %568
%570 = sext i32 %566 to i64
%571 = call i32 @strncmp(i8* %567, i8* %569, i64 %570)
store i32 %571, i32* %7
%572 = icmp slt i32 %571, 0
br i1 %572, label %581, label %573
573: ; preds = %560
%574 = icmp eq i32 %571, 0
%575 = icmp slt i32 %563, %564
%576 = select i1 %574, i1 %575, i1 false
br label %581
577: ; preds = %525
%578 = load i32, i32* %7
%579 = load i32, i32* %8
%580 = icmp slt i32 %578, %579
br label %581
581: ; preds = %573, %560, %577
%582 = phi i1 [ %580, %577 ], [ true, %560 ], [ %576, %573 ]
%583 = zext i1 %582 to i32
store i32 %583, i32* %3
br label %730
584: ; preds = %518
%585 = 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)
%586 = icmp eq i32 %585, 0
br i1 %586, label %599, label %587
587: ; preds = %584
%588 = load i32, i32* %5
%589 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %588, i32* %7)
%590 = icmp eq i32 %589, 0
br i1 %590, label %730, label %591
591: ; preds = %587
%592 = load i32, i32* %6
%593 = call i32 @DoArithmEval(i8* %0, i32 %592, i32 %49, i32* %8)
%594 = icmp eq i32 %593, 0
br i1 %594, label %730, label %595
595: ; preds = %591
%596 = load i32, i32* %7
%597 = load i32, i32* %8
%598 = add nsw i32 %597, %596
store i32 %598, i32* %3
br label %730
599: ; preds = %584
%600 = 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)
%601 = icmp eq i32 %600, 0
br i1 %601, label %616, label %602
602: ; preds = %599
%603 = load i32, i32* %5
%604 = icmp eq i32 %603, %32
br i1 %604, label %616, label %605
605: ; preds = %602
%606 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %603, i32* %7)
%607 = icmp eq i32 %606, 0
br i1 %607, label %730, label %608
608: ; preds = %605
%609 = load i32, i32* %6
%610 = call i32 @DoArithmEval(i8* %0, i32 %609, i32 %49, i32* %8)
%611 = icmp eq i32 %610, 0
br i1 %611, label %730, label %612
612: ; preds = %608
%613 = load i32, i32* %7
%614 = load i32, i32* %8
%615 = sub nsw i32 %613, %614
store i32 %615, i32* %3
br label %730
616: ; preds = %602, %599
%617 = 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.15, i64 0, i64 0), i32* %5, i32* %6)
%618 = icmp eq i32 %617, 0
br i1 %618, label %631, label %619
619: ; preds = %616
%620 = load i32, i32* %5
%621 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %620, i32* %7)
%622 = icmp eq i32 %621, 0
br i1 %622, label %730, label %623
623: ; preds = %619
%624 = load i32, i32* %6
%625 = call i32 @DoArithmEval(i8* %0, i32 %624, i32 %49, i32* %8)
%626 = icmp eq i32 %625, 0
br i1 %626, label %730, label %627
627: ; preds = %623
%628 = load i32, i32* %7
%629 = load i32, i32* %8
%630 = mul nsw i32 %629, %628
store i32 %630, i32* %3
br label %730
631: ; preds = %616
%632 = 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)
%633 = icmp eq i32 %632, 0
br i1 %633, label %652, label %634
634: ; preds = %631
%635 = load i32, i32* %5
%636 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %635, i32* %7)
%637 = icmp eq i32 %636, 0
br i1 %637, label %730, label %638
638: ; preds = %634
%639 = load i32, i32* %6
%640 = call i32 @DoArithmEval(i8* %0, i32 %639, i32 %49, i32* %8)
%641 = icmp eq i32 %640, 0
br i1 %641, label %730, label %642
642: ; preds = %638
%643 = load i32, i32* %8
%644 = icmp eq i32 %643, 0
br i1 %644, label %645, label %648
645: ; preds = %642
%646 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.17, i64 0, i64 0))
%647 = load i32, i32* %8
br label %648
648: ; preds = %645, %642
%649 = phi i32 [ %647, %645 ], [ %643, %642 ]
%650 = load i32, i32* %7
%651 = sdiv i32 %650, %649
store i32 %651, i32* %3
br label %730
652: ; preds = %631
%653 = 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.18, i64 0, i64 0), i32* %5, i32* %6)
%654 = icmp eq i32 %653, 0
br i1 %654, label %673, label %655
655: ; preds = %652
%656 = load i32, i32* %5
%657 = call i32 @DoArithmEval(i8* %0, i32 %32, i32 %656, i32* %7)
%658 = icmp eq i32 %657, 0
br i1 %658, label %730, label %659
659: ; preds = %655
%660 = load i32, i32* %6
%661 = call i32 @DoArithmEval(i8* %0, i32 %660, i32 %49, i32* %8)
%662 = icmp eq i32 %661, 0
br i1 %662, label %730, label %663
663: ; preds = %659
%664 = load i32, i32* %8
%665 = icmp eq i32 %664, 0
br i1 %665, label %666, label %669
666: ; preds = %663
%667 = call i32 (i8*, ...) bitcast (i32 (...)* @bug to i32 (i8*, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.17, i64 0, i64 0))
%668 = load i32, i32* %8
br label %669
669: ; preds = %666, %663
%670 = phi i32 [ %668, %666 ], [ %664, %663 ]
%671 = load i32, i32* %7
%672 = srem i32 %671, %670
store i32 %672, i32* %3
br label %730
673: ; preds = %652
%674 = getelementptr inbounds i8, i8* %0, i64 %34
%675 = load i8, i8* %674
switch i8 %675, label %698 [
i8 126, label %676
i8 33, label %683
i8 45, label %691
]
676: ; preds = %673
%677 = add nsw i32 %32, 1
%678 = call i32 @DoArithmEval(i8* %0, i32 %677, i32 %49, i32* %7)
%679 = icmp eq i32 %678, 0
br i1 %679, label %730, label %680
680: ; preds = %676
%681 = load i32, i32* %7
%682 = xor i32 %681, -1
store i32 %682, i32* %3
br label %730
683: ; preds = %673
%684 = add nsw i32 %32, 1
%685 = call i32 @DoArithmEval(i8* %0, i32 %684, i32 %49, i32* %7)
%686 = icmp eq i32 %685, 0
br i1 %686, label %730, label %687
687: ; preds = %683
%688 = load i32, i32* %7
%689 = icmp eq i32 %688, 0
%690 = zext i1 %689 to i32
store i32 %690, i32* %3
br label %730
691: ; preds = %673
%692 = add nsw i32 %32, 1
%693 = call i32 @DoArithmEval(i8* %0, i32 %692, i32 %49, i32* %7)
%694 = icmp eq i32 %693, 0
br i1 %694, label %730, label %695
695: ; preds = %691
%696 = load i32, i32* %7
%697 = sub nsw i32 0, %696
store i32 %697, i32* %3
br label %730
698: ; preds = %673
%699 = call i32 @strncmp(i8* %674, i8* dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i64 0, i64 0), i64 7)
%700 = icmp eq i32 %699, 0
br i1 %700, label %701, label %710
701: ; preds = %698
%702 = add nsw i32 %49, -1
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds i8, i8* %0, i64 %703
%705 = load i8, i8* %704
%706 = icmp eq i8 %705, 41
br i1 %706, label %707, label %730
707: ; preds = %701
%708 = sub i32 -8, %32
%709 = add i32 %708, %49
store i32 %709, i32* %3
br label %730
710: ; preds = %698
%711 = icmp eq i8 %675, 40
br i1 %711, label %712, label %721
712: ; preds = %710
%713 = add nsw i32 %49, -1
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds i8, i8* %0, i64 %714
%716 = load i8, i8* %715
%717 = icmp eq i8 %716, 41
br i1 %717, label %718, label %730
718: ; preds = %712
%719 = add nsw i32 %32, 1
%720 = call i32 @DoArithmEval(i8* %0, i32 %719, i32 %713, i32* %3)
br label %730
721: ; preds = %710
%722 = sext i32 %49 to i64
%723 = getelementptr inbounds i8, i8* %0, i64 %722
%724 = load i8, i8* %723
store i8 0, i8* %723
%725 = call i64 @strtol(i8* %674, i8** %9, i32 0)
%726 = trunc i64 %725 to i32
store i32 %726, i32* %3
store i8 %724, i8* %723
%727 = load i8*, i8** %9
%728 = icmp eq i8* %727, %723
%729 = zext i1 %728 to i32
br label %730
730: ; preds = %712, %701, %691, %683, %676, %655, %659, %634, %638, %619, %623, %605, %608, %587, %591, %299, %316, %251, %243, %242, %189, %181, %180, %120, %124, %105, %109, %90, %94, %72, %76, %54, %58, %48, %721, %718, %707, %695, %687, %680, %669, %648, %627, %612, %595, %581, %515, %449, %384, %128, %113, %98, %80, %62
%731 = phi i32 [ 1, %62 ], [ 1, %80 ], [ 1, %98 ], [ 1, %113 ], [ 1, %128 ], [ 1, %384 ], [ 1, %449 ], [ 1, %515 ], [ 1, %581 ], [ 1, %595 ], [ 1, %612 ], [ 1, %627 ], [ 1, %648 ], [ 1, %669 ], [ 1, %680 ], [ 1, %687 ], [ 1, %695 ], [ 1, %707 ], [ %720, %718 ], [ %729, %721 ], [ 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 ], [ 1, %316 ], [ 1, %299 ], [ 0, %591 ], [ 0, %587 ], [ 0, %608 ], [ 0, %605 ], [ 0, %623 ], [ 0, %619 ], [ 0, %638 ], [ 0, %634 ], [ 0, %659 ], [ 0, %655 ], [ 0, %676 ], [ 0, %683 ], [ 0, %691 ], [ 0, %701 ], [ 0, %712 ]
ret i32 %731
}