#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ SpliceInfix(char *, int, int, char *, int *, int *);
int /*<<< orphan*/ bug(char *);
scalar_t__ iswhite(char);
int strlen(char *);
int /*<<< orphan*/ strncmp(char *, char *, int);
scalar_t__ strtol(char *, char **, int /*<<< orphan*/);
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");
    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,-0x41(%rbp)
jge    11b2 <DoArithmEval+0x42>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    11c2 <DoArithmEval+0x52>
jmp    11d0 <DoArithmEval+0x60>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1186 <DoArithmEval+0x16>
jmp    11d5 <DoArithmEval+0x65>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x42(%rbp)
jge    1206 <DoArithmEval+0x96>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x42(%rbp)
mov    -0x42(%rbp),%al
test   $0x1,%al
jne    1216 <DoArithmEval+0xa6>
jmp    1224 <DoArithmEval+0xb4>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    11d5 <DoArithmEval+0x65>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    123c <DoArithmEval+0xcc>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1db3(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     12db <DoArithmEval+0x16b>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     129c <DoArithmEval+0x12c>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    12a8 <DoArithmEval+0x138>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x43(%rbp)
jne    12c1 <DoArithmEval+0x151>
cmpl   $0x0,-0x30(%rbp)
setne  %al
mov    %al,-0x43(%rbp)
mov    -0x43(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1d17(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     137a <DoArithmEval+0x20a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     133b <DoArithmEval+0x1cb>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1347 <DoArithmEval+0x1d7>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x44(%rbp)
je     1360 <DoArithmEval+0x1f0>
cmpl   $0x0,-0x30(%rbp)
setne  %al
mov    %al,-0x44(%rbp)
mov    -0x44(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1c76(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     13fe <DoArithmEval+0x28e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     13da <DoArithmEval+0x26a>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    13e6 <DoArithmEval+0x276>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x2c(%rbp),%ecx
or     -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1bf7(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1482 <DoArithmEval+0x312>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     145e <DoArithmEval+0x2ee>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    146a <DoArithmEval+0x2fa>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x2c(%rbp),%ecx
xor    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1b71(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1506 <DoArithmEval+0x396>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     14e2 <DoArithmEval+0x372>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    14ee <DoArithmEval+0x37e>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x2c(%rbp),%ecx
and    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1af1(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1683 <DoArithmEval+0x513>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1566 <DoArithmEval+0x3f6>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1663 <DoArithmEval+0x4f3>
jmp    156b <DoArithmEval+0x3fb>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x45(%rbp)
jge    159c <DoArithmEval+0x42c>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    15ac <DoArithmEval+0x43c>
jmp    15ba <DoArithmEval+0x44a>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    156b <DoArithmEval+0x3fb>
jmp    15bf <DoArithmEval+0x44f>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x46(%rbp)
jle    15eb <DoArithmEval+0x47b>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x46(%rbp)
mov    -0x46(%rbp),%al
test   $0x1,%al
jne    15fb <DoArithmEval+0x48b>
jmp    1609 <DoArithmEval+0x499>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15bf <DoArithmEval+0x44f>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
je     162c <DoArithmEval+0x4bc>
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
jmp    165e <DoArithmEval+0x4ee>
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),%edx
sub    -0x14(%rbp),%edx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
setne  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1677 <DoArithmEval+0x507>
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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1977(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1800 <DoArithmEval+0x690>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     16e3 <DoArithmEval+0x573>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    17e0 <DoArithmEval+0x670>
jmp    16e8 <DoArithmEval+0x578>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x47(%rbp)
jge    1719 <DoArithmEval+0x5a9>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x47(%rbp)
mov    -0x47(%rbp),%al
test   $0x1,%al
jne    1729 <DoArithmEval+0x5b9>
jmp    1737 <DoArithmEval+0x5c7>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    16e8 <DoArithmEval+0x578>
jmp    173c <DoArithmEval+0x5cc>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x48(%rbp)
jle    1768 <DoArithmEval+0x5f8>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x48(%rbp)
mov    -0x48(%rbp),%al
test   $0x1,%al
jne    1778 <DoArithmEval+0x608>
jmp    1786 <DoArithmEval+0x616>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    173c <DoArithmEval+0x5cc>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
je     17a9 <DoArithmEval+0x639>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
jmp    17db <DoArithmEval+0x66b>
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),%edx
sub    -0x14(%rbp),%edx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    17f4 <DoArithmEval+0x684>
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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x17fd(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1840 <DoArithmEval+0x6d0>
lea    0x17e2(%rip),%rdi
call   1040 <bug@plt>
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x17ea(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     19f2 <DoArithmEval+0x882>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     18a0 <DoArithmEval+0x730>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    19d2 <DoArithmEval+0x862>
jmp    18a5 <DoArithmEval+0x735>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x49(%rbp)
jge    18d6 <DoArithmEval+0x766>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    18e6 <DoArithmEval+0x776>
jmp    18f4 <DoArithmEval+0x784>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    18a5 <DoArithmEval+0x735>
jmp    18f9 <DoArithmEval+0x789>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x4a(%rbp)
jle    1925 <DoArithmEval+0x7b5>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4a(%rbp)
mov    -0x4a(%rbp),%al
test   $0x1,%al
jne    1935 <DoArithmEval+0x7c5>
jmp    1943 <DoArithmEval+0x7d3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    18f9 <DoArithmEval+0x789>
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    1966 <DoArithmEval+0x7f6>
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
mov    -0x34(%rbp),%edx
call   1030 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x4b(%rbp)
jg     19bf <DoArithmEval+0x84f>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x4c(%rbp)
jne    19b9 <DoArithmEval+0x849>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setge  %al
mov    %al,-0x4c(%rbp)
mov    -0x4c(%rbp),%al
mov    %al,-0x4b(%rbp)
mov    -0x4b(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    19e6 <DoArithmEval+0x876>
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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x163b(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1ba4 <DoArithmEval+0xa34>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1a52 <DoArithmEval+0x8e2>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1b84 <DoArithmEval+0xa14>
jmp    1a57 <DoArithmEval+0x8e7>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x4d(%rbp)
jge    1a88 <DoArithmEval+0x918>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
test   $0x1,%al
jne    1a98 <DoArithmEval+0x928>
jmp    1aa6 <DoArithmEval+0x936>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1a57 <DoArithmEval+0x8e7>
jmp    1aab <DoArithmEval+0x93b>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x4e(%rbp)
jle    1ad7 <DoArithmEval+0x967>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4e(%rbp)
mov    -0x4e(%rbp),%al
test   $0x1,%al
jne    1ae7 <DoArithmEval+0x977>
jmp    1af5 <DoArithmEval+0x985>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1aab <DoArithmEval+0x93b>
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    1b18 <DoArithmEval+0x9a8>
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
mov    -0x34(%rbp),%edx
call   1030 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x4f(%rbp)
jg     1b71 <DoArithmEval+0xa01>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x50(%rbp)
jne    1b6b <DoArithmEval+0x9fb>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setg   %al
mov    %al,-0x50(%rbp)
mov    -0x50(%rbp),%al
mov    %al,-0x4f(%rbp)
mov    -0x4f(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1b98 <DoArithmEval+0xa28>
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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x148b(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1d56 <DoArithmEval+0xbe6>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1c04 <DoArithmEval+0xa94>
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+0xbc6>
jmp    1c09 <DoArithmEval+0xa99>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x51(%rbp)
jge    1c3a <DoArithmEval+0xaca>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    1c4a <DoArithmEval+0xada>
jmp    1c58 <DoArithmEval+0xae8>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1c09 <DoArithmEval+0xa99>
jmp    1c5d <DoArithmEval+0xaed>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x52(%rbp)
jle    1c89 <DoArithmEval+0xb19>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
test   $0x1,%al
jne    1c99 <DoArithmEval+0xb29>
jmp    1ca7 <DoArithmEval+0xb37>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1c5d <DoArithmEval+0xaed>
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    1cca <DoArithmEval+0xb5a>
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
mov    -0x34(%rbp),%edx
call   1030 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x53(%rbp)
jl     1d23 <DoArithmEval+0xbb3>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x54(%rbp)
jne    1d1d <DoArithmEval+0xbad>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setle  %al
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1d4a <DoArithmEval+0xbda>
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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x12dc(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1f08 <DoArithmEval+0xd98>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1db6 <DoArithmEval+0xc46>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1ee8 <DoArithmEval+0xd78>
jmp    1dbb <DoArithmEval+0xc4b>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x55(%rbp)
jge    1dec <DoArithmEval+0xc7c>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
test   $0x1,%al
jne    1dfc <DoArithmEval+0xc8c>
jmp    1e0a <DoArithmEval+0xc9a>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1dbb <DoArithmEval+0xc4b>
jmp    1e0f <DoArithmEval+0xc9f>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x56(%rbp)
jle    1e3b <DoArithmEval+0xccb>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x56(%rbp)
mov    -0x56(%rbp),%al
test   $0x1,%al
jne    1e4b <DoArithmEval+0xcdb>
jmp    1e59 <DoArithmEval+0xce9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1e0f <DoArithmEval+0xc9f>
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    1e7c <DoArithmEval+0xd0c>
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
mov    -0x34(%rbp),%edx
call   1030 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x57(%rbp)
jl     1ed5 <DoArithmEval+0xd65>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x58(%rbp)
jne    1ecf <DoArithmEval+0xd5f>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x58(%rbp)
mov    -0x58(%rbp),%al
mov    %al,-0x57(%rbp)
mov    -0x57(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1efc <DoArithmEval+0xd8c>
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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x112c(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     1f8c <DoArithmEval+0xe1c>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1f68 <DoArithmEval+0xdf8>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    1f74 <DoArithmEval+0xe04>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x10aa(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     2021 <DoArithmEval+0xeb1>
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     201c <DoArithmEval+0xeac>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     1ff8 <DoArithmEval+0xe88>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2004 <DoArithmEval+0xe94>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x2c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
jmp    2021 <DoArithmEval+0xeb1>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1017(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     20a6 <DoArithmEval+0xf36>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     2081 <DoArithmEval+0xf11>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    208d <DoArithmEval+0xf1d>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x2c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xf94(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     2143 <DoArithmEval+0xfd3>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     2106 <DoArithmEval+0xf96>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    2112 <DoArithmEval+0xfa2>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
cmpl   $0x0,-0x30(%rbp)
jne    2128 <DoArithmEval+0xfb8>
lea    0xf2a(%rip),%rdi
call   1040 <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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xf18(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1090 <SpliceInfix@plt>
cmp    $0x0,%rax
je     21de <DoArithmEval+0x106e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
je     21a3 <DoArithmEval+0x1033>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1060 <DoArithmEval@plt>
cmp    $0x0,%eax
jne    21af <DoArithmEval+0x103f>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
cmpl   $0x0,-0x30(%rbp)
jne    21c5 <DoArithmEval+0x1055>
lea    0xe8d(%rip),%rdi
call   1040 <bug@plt>
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %edx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7e,%eax
jne    2236 <DoArithmEval+0x10c6>
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    221e <DoArithmEval+0x10ae>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x2c(%rbp),%ecx
xor    $0xffffffff,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x21,%eax
jne    2296 <DoArithmEval+0x1126>
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    2276 <DoArithmEval+0x1106>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    22ed <DoArithmEval+0x117d>
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    22d6 <DoArithmEval+0x1166>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
xor    %ecx,%ecx
sub    -0x2c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
lea    0xd6b(%rip),%rdi
call   1050 <strlen@plt>
mov    -0x60(%rbp),%rdi
mov    %eax,%edx
lea    0xd59(%rip),%rsi
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    2375 <DoArithmEval+0x1205>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     2349 <DoArithmEval+0x11d9>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x64(%rbp)
lea    0xd1d(%rip),%rdi
call   1050 <strlen@plt>
mov    -0x64(%rbp),%ecx
sub    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    23d1 <DoArithmEval+0x1261>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     23b0 <DoArithmEval+0x1240>
movl   $0x0,-0x4(%rbp)
jmp    2434 <DoArithmEval+0x12c4>
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    2434 <DoArithmEval+0x12c4>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x35(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
lea    -0x40(%rbp),%rsi
xor    %edx,%edx
call   1070 <strtol@plt>
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x35(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DoArithmEval>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r15
mov    %edx,%r12d
mov    %rdi,%rbp
cmp    %edx,%esi
jge    11ce <DoArithmEval+0x5e>
mov    %r12d,%ecx
mov    %r15,0x20(%rsp)
mov    %esi,0x10(%rsp)
movslq %esi,%rax
movslq %r12d,%rbx
mov    %rbp,%r14
lea    (%rax,%rbp,1),%r13
mov    %rbx,%r15
sub    %rax,%r15
xor    %ebp,%ebp
nopl   0x0(%rax)
movsbl 0x0(%r13,%rbp,1),%edi
call   1080 <iswhite@plt>
test   %rax,%rax
je     11d3 <DoArithmEval+0x63>
add    $0x1,%rbp
cmp    %rbp,%r15
jne    11b0 <DoArithmEval+0x40>
mov    %r12d,%esi
jmp    11d9 <DoArithmEval+0x69>
movslq %r12d,%rbx
jmp    11e1 <DoArithmEval+0x71>
mov    0x10(%rsp),%esi
add    %ebp,%esi
mov    0x20(%rsp),%r15
mov    %r14,%rbp
movslq %esi,%r14
cmp    %r12d,%r14d
mov    %esi,0x10(%rsp)
cmovl  %esi,%r12d
nop
cmp    %r14,%rbx
jle    120e <DoArithmEval+0x9e>
movsbl -0x1(%rbp,%rbx,1),%edi
add    $0xffffffffffffffff,%rbx
call   1080 <iswhite@plt>
test   %rax,%rax
jne    11f0 <DoArithmEval+0x80>
add    $0x1,%ebx
mov    %ebx,%r12d
xor    %r13d,%r13d
mov    0x10(%rsp),%ebx
cmp    %ebx,%r12d
jne    122c <DoArithmEval+0xbc>
mov    %r13d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xdcd(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1296 <DoArithmEval+0x126>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0x18(%rsp),%eax
xor    %ecx,%ecx
or     0x14(%rsp),%eax
setne  %cl
mov    %ecx,(%r15)
mov    $0x1,%r13d
jmp    121a <DoArithmEval+0xaa>
lea    0xd66(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     130a <DoArithmEval+0x19a>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
cmpl   $0x0,0x18(%rsp)
setne  %al
cmpl   $0x0,0x14(%rsp)
setne  %cl
and    %al,%cl
movzbl %cl,%eax
jmp    1437 <DoArithmEval+0x2c7>
lea    0xcf0(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1371 <DoArithmEval+0x201>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0x14(%rsp),%eax
or     0x18(%rsp),%eax
jmp    1437 <DoArithmEval+0x2c7>
lea    0xc8e(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     13d5 <DoArithmEval+0x265>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0x14(%rsp),%eax
xor    0x18(%rsp),%eax
jmp    1437 <DoArithmEval+0x2c7>
lea    0xc28(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1445 <DoArithmEval+0x2d5>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0x14(%rsp),%eax
and    0x18(%rsp),%eax
mov    %eax,(%r15)
mov    $0x1,%r13d
jmp    121a <DoArithmEval+0xaa>
lea    0xbbc(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1529 <DoArithmEval+0x3b9>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     14aa <DoArithmEval+0x33a>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     14aa <DoArithmEval+0x33a>
mov    0x18(%rsp),%eax
xor    %ecx,%ecx
cmp    0x14(%rsp),%eax
jmp    1288 <DoArithmEval+0x118>
mov    0x8(%rsp),%eax
cmp    %eax,%ebx
jge    14d2 <DoArithmEval+0x362>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   1080 <iswhite@plt>
test   %rax,%rax
je     14d2 <DoArithmEval+0x362>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     14b2 <DoArithmEval+0x342>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r12d
jle    14fd <DoArithmEval+0x38d>
movslq %ecx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   1080 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     14fd <DoArithmEval+0x38d>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r12d
jg     14db <DoArithmEval+0x36b>
mov    0x8(%rsp),%edx
sub    %ebx,%edx
sub    %ecx,%r12d
cmp    %r12d,%edx
jne    1591 <DoArithmEval+0x421>
add    %rbp,%r14
movslq %ecx,%rsi
add    %rbp,%rsi
mov    %r14,%rdi
call   1030 <strncmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
jmp    1288 <DoArithmEval+0x118>
lea    0xadb(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1621 <DoArithmEval+0x4b1>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     15a3 <DoArithmEval+0x433>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     15a3 <DoArithmEval+0x433>
mov    0x18(%rsp),%eax
xor    %ecx,%ecx
cmp    0x14(%rsp),%eax
sete   %cl
jmp    128b <DoArithmEval+0x11b>
movl   $0x1,(%r15)
mov    $0x1,%r13d
jmp    121a <DoArithmEval+0xaa>
mov    0x8(%rsp),%eax
cmp    %eax,%ebx
jge    15cb <DoArithmEval+0x45b>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   1080 <iswhite@plt>
test   %rax,%rax
je     15cb <DoArithmEval+0x45b>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     15ab <DoArithmEval+0x43b>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r12d
jle    15f6 <DoArithmEval+0x486>
movslq %ecx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   1080 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     15f6 <DoArithmEval+0x486>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r12d
jg     15d4 <DoArithmEval+0x464>
mov    0x8(%rsp),%edx
sub    %ebx,%edx
sub    %ecx,%r12d
cmp    %r12d,%edx
jne    165b <DoArithmEval+0x4eb>
add    %rbp,%r14
movslq %ecx,%rsi
add    %rbp,%rsi
mov    %r14,%rdi
call   1030 <strncmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
sete   %cl
jmp    128b <DoArithmEval+0x11b>
lea    0x9e6(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     166d <DoArithmEval+0x4fd>
lea    0x9c6(%rip),%rdi
call   1040 <bug@plt>
mov    $0x1,%r13d
jmp    121a <DoArithmEval+0xaa>
movl   $0x0,(%r15)
mov    $0x1,%r13d
jmp    121a <DoArithmEval+0xaa>
lea    0x9c7(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1770 <DoArithmEval+0x600>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     16d3 <DoArithmEval+0x563>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     16d3 <DoArithmEval+0x563>
mov    0x18(%rsp),%eax
cmp    0x14(%rsp),%eax
setge  %cl
jmp    1901 <DoArithmEval+0x791>
mov    %r15,%r13
mov    0x8(%rsp),%eax
cmp    %eax,%ebx
jge    16fe <DoArithmEval+0x58e>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   1080 <iswhite@plt>
test   %rax,%rax
je     16fe <DoArithmEval+0x58e>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     16de <DoArithmEval+0x56e>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r12d
jle    1729 <DoArithmEval+0x5b9>
movslq %ecx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   1080 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1729 <DoArithmEval+0x5b9>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r12d
jg     1707 <DoArithmEval+0x597>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
mov    %r12d,%ebx
sub    %ecx,%r12d
cmp    %r12d,%eax
cmovle %eax,%r12d
add    %rbp,%r14
movslq %ecx,%rsi
add    %rbp,%rsi
mov    %r14,%rdi
mov    %r12d,%edx
call   1030 <strncmp@plt>
mov    %eax,0x18(%rsp)
mov    $0x1,%cl
test   %eax,%eax
mov    %r13,%r15
jg     1901 <DoArithmEval+0x791>
je     18ed <DoArithmEval+0x77d>
xor    %ecx,%ecx
jmp    18fe <DoArithmEval+0x78e>
mov    %r15,0x20(%rsp)
lea    0x8c2(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%r15d
mov    %r12d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1882 <DoArithmEval+0x712>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     17db <DoArithmEval+0x66b>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     17db <DoArithmEval+0x66b>
mov    0x18(%rsp),%eax
cmp    0x14(%rsp),%eax
jmp    187a <DoArithmEval+0x70a>
mov    0x8(%rsp),%eax
mov    0x10(%rsp),%ebx
cmp    %eax,%ebx
jge    1807 <DoArithmEval+0x697>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   1080 <iswhite@plt>
test   %rax,%rax
je     1807 <DoArithmEval+0x697>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     17e7 <DoArithmEval+0x677>
mov    0xc(%rsp),%ecx
mov    %r15d,%ebx
cmp    %ecx,%r15d
jle    1834 <DoArithmEval+0x6c4>
movslq %ecx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   1080 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1834 <DoArithmEval+0x6c4>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%ebx
jg     1813 <DoArithmEval+0x6a3>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
mov    %ebx,%edx
sub    %ecx,%edx
cmp    %edx,%eax
cmovle %eax,%edx
add    %rbp,%r14
movslq %ecx,%rsi
add    %rbp,%rsi
mov    %r14,%rdi
call   1030 <strncmp@plt>
mov    %eax,0x18(%rsp)
mov    $0x1,%cl
test   %eax,%eax
jg     1aa9 <DoArithmEval+0x939>
jne    1aa7 <DoArithmEval+0x937>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
sub    0xc(%rsp),%r15d
cmp    %r15d,%eax
setg   %cl
jmp    1aa9 <DoArithmEval+0x939>
lea    0x7b7(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%r12
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r15d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     19b2 <DoArithmEval+0x842>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1909 <DoArithmEval+0x799>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1909 <DoArithmEval+0x799>
mov    0x18(%rsp),%eax
cmp    0x14(%rsp),%eax
setle  %cl
jmp    1aa9 <DoArithmEval+0x939>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
sub    0xc(%rsp),%ebx
cmp    %ebx,%eax
setge  %cl
mov    %r13,%r15
movzbl %cl,%eax
jmp    1437 <DoArithmEval+0x2c7>
mov    0x8(%rsp),%eax
cmp    %eax,0x10(%rsp)
jge    1938 <DoArithmEval+0x7c8>
mov    %r12,%rbx
cltq
movsbl -0x1(%rax,%rbx,1),%edi
call   1080 <iswhite@plt>
test   %rax,%rax
je     1938 <DoArithmEval+0x7c8>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,0x10(%rsp)
jl     1916 <DoArithmEval+0x7a6>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r15d
jle    1963 <DoArithmEval+0x7f3>
movslq %ecx,%rax
movsbl (%r12,%rax,1),%edi
call   1080 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1963 <DoArithmEval+0x7f3>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r15d
jg     1941 <DoArithmEval+0x7d1>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
mov    %r15d,%edx
sub    %ecx,%edx
cmp    %edx,%eax
cmovle %eax,%edx
add    %r12,%r14
movslq %ecx,%rsi
add    %r12,%rsi
mov    %r14,%rdi
call   1030 <strncmp@plt>
mov    %eax,0x18(%rsp)
mov    $0x1,%cl
test   %eax,%eax
js     1aa9 <DoArithmEval+0x939>
jne    1aa7 <DoArithmEval+0x937>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
sub    0xc(%rsp),%r15d
cmp    %r15d,%eax
setle  %cl
jmp    1aa9 <DoArithmEval+0x939>
lea    0x68a(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1abe <DoArithmEval+0x94e>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1a1c <DoArithmEval+0x8ac>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     1a1c <DoArithmEval+0x8ac>
mov    0x18(%rsp),%eax
cmp    0x14(%rsp),%eax
setl   %cl
jmp    1aa9 <DoArithmEval+0x939>
mov    0x8(%rsp),%eax
cmp    %eax,0x10(%rsp)
jge    1a49 <DoArithmEval+0x8d9>
cltq
movsbl -0x1(%rax,%r12,1),%edi
call   1080 <iswhite@plt>
test   %rax,%rax
je     1a49 <DoArithmEval+0x8d9>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,0x10(%rsp)
jl     1a26 <DoArithmEval+0x8b6>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r15d
jle    1a74 <DoArithmEval+0x904>
movslq %ecx,%rax
movsbl (%r12,%rax,1),%edi
call   1080 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1a74 <DoArithmEval+0x904>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r15d
jg     1a52 <DoArithmEval+0x8e2>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
mov    %r15d,%edx
sub    %ecx,%edx
cmp    %edx,%eax
cmovle %eax,%edx
add    %r12,%r14
movslq %ecx,%rsi
add    %r12,%rsi
mov    %r14,%rdi
call   1030 <strncmp@plt>
mov    %eax,0x18(%rsp)
mov    $0x1,%cl
test   %eax,%eax
js     1aa9 <DoArithmEval+0x939>
je     1bd6 <DoArithmEval+0xa66>
xor    %ecx,%ecx
movzbl %cl,%eax
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
mov    $0x1,%r13d
jmp    121a <DoArithmEval+0xaa>
lea    0x580(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1b2e <DoArithmEval+0x9be>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     121a <DoArithmEval+0xaa>
mov    0x14(%rsp),%eax
add    0x18(%rsp),%eax
jmp    1437 <DoArithmEval+0x2c7>
lea    0x512(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1b61 <DoArithmEval+0x9f1>
mov    0x8(%rsp),%edx
cmp    0x10(%rsp),%edx
jne    1bee <DoArithmEval+0xa7e>
lea    0x4e1(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1c35 <DoArithmEval+0xac5>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     121a <DoArithmEval+0xaa>
mov    0x14(%rsp),%eax
imul   0x18(%rsp),%eax
jmp    1437 <DoArithmEval+0x2c7>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
sub    0xc(%rsp),%r15d
cmp    %r15d,%eax
setl   %cl
jmp    1aa9 <DoArithmEval+0x939>
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     121a <DoArithmEval+0xaa>
mov    0x18(%rsp),%eax
sub    0x14(%rsp),%eax
jmp    1437 <DoArithmEval+0x2c7>
lea    0x40f(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1cb7 <DoArithmEval+0xb47>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
jne    1cab <DoArithmEval+0xb3b>
lea    0x3ab(%rip),%rdi
call   1040 <bug@plt>
mov    0x14(%rsp),%ecx
mov    0x18(%rsp),%eax
cltd
idiv   %ecx
jmp    1aac <DoArithmEval+0x93c>
lea    0x3ae(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1090 <SpliceInfix@plt>
test   %rax,%rax
je     1d46 <DoArithmEval+0xbd6>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
je     121a <DoArithmEval+0xaa>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
jne    1d2d <DoArithmEval+0xbbd>
lea    0x329(%rip),%rdi
call   1040 <bug@plt>
mov    0x14(%rsp),%ecx
mov    0x18(%rsp),%eax
cltd
idiv   %ecx
mov    0x20(%rsp),%rax
mov    %edx,(%rax)
mov    $0x1,%r13d
jmp    121a <DoArithmEval+0xaa>
mov    (%r12,%r14,1),%al
cmp    $0x21,%al
je     1d89 <DoArithmEval+0xc19>
cmp    $0x2d,%al
je     1dbc <DoArithmEval+0xc4c>
cmp    $0x7e,%al
jne    1deb <DoArithmEval+0xc7b>
mov    0x10(%rsp),%esi
add    $0x1,%esi
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     121a <DoArithmEval+0xaa>
mov    0x18(%rsp),%eax
not    %eax
jmp    1437 <DoArithmEval+0x2c7>
mov    0x10(%rsp),%esi
add    $0x1,%esi
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     121a <DoArithmEval+0xaa>
xor    %eax,%eax
cmpl   $0x0,0x18(%rsp)
sete   %al
jmp    1437 <DoArithmEval+0x2c7>
mov    0x10(%rsp),%esi
add    $0x1,%esi
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1060 <DoArithmEval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     121a <DoArithmEval+0xaa>
xor    %eax,%eax
sub    0x18(%rsp),%eax
jmp    1437 <DoArithmEval+0x2c7>
add    %r12,%r14
lea    0x279(%rip),%rbx
mov    %rbx,%rdi
call   1050 <strlen@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   1030 <strncmp@plt>
test   %eax,%eax
je     1e43 <DoArithmEval+0xcd3>
cmpb   $0x28,(%r14)
jne    1e7a <DoArithmEval+0xd0a>
movslq %r15d,%rdx
cmpb   $0x29,-0x1(%r12,%rdx,1)
mov    0x20(%rsp),%rcx
jne    121a <DoArithmEval+0xaa>
add    $0xffffffffffffffff,%rdx
mov    0x10(%rsp),%esi
add    $0x1,%esi
mov    %r12,%rdi
call   1060 <DoArithmEval@plt>
mov    %eax,%r13d
jmp    121a <DoArithmEval+0xaa>
movslq %r15d,%rax
cmpb   $0x29,-0x1(%rax,%r12,1)
mov    0x20(%rsp),%rbx
jne    121a <DoArithmEval+0xaa>
lea    0x218(%rip),%rdi
call   1050 <strlen@plt>
mov    0x10(%rsp),%ecx
add    %eax,%ecx
sub    %ecx,%r15d
mov    %r15d,(%rbx)
mov    $0x1,%r13d
jmp    121a <DoArithmEval+0xaa>
movslq %r15d,%rbx
mov    %r12,%rbp
lea    (%r12,%rbx,1),%r15
mov    (%r12,%rbx,1),%r12b
movb   $0x0,0x0(%rbp,%rbx,1)
lea    0x18(%rsp),%rsi
mov    %r14,%rdi
xor    %edx,%edx
call   1070 <strtol@plt>
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
mov    %r12b,0x0(%rbp,%rbx,1)
xor    %r13d,%r13d
cmp    %r15,0x18(%rsp)
sete   %r13b
jmp    121a <DoArithmEval+0xaa>

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

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