#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 */
int /*<<< orphan*/ bug(char *);
scalar_t__ fnmatch(char *, char *, int /*<<< orphan*/);
int /*<<< orphan*/ free(char *);
scalar_t__ iswhite(char);
scalar_t__ splice_infix(char *, int, int, char *, int *, int *);
char *strdup(char *);
int strlen(char *);
int /*<<< orphan*/ strncmp(char *, char *, int);
scalar_t__ strtol(char *, char **, int /*<<< orphan*/);
int do_arithm_eval(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 (splice_infix(buf, pos1, pos2, "||", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 || result2;
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, "&&", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 && result2;
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, "|", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 | result2;
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, "^", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 ^ result2;
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, "&", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 & result2;
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, "!=", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(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 (splice_infix(buf, pos1, pos2, "==", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(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 (splice_infix(buf, pos1, pos2, "=~", &spl1, &spl2)) {
    bug("globbing support has not been compiled in");
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2)) {
      char *str1, *str2;
      while ((pos1 < spl1) && iswhite(buf[spl1 - 1]))
        spl1--;
      while ((pos2 > spl2) && iswhite(buf[spl2]))
        spl2++;
      str1 = strdup(buf + pos1);
      str1[spl1 - pos1] = '\0';
      str2 = strdup(buf + spl2);
      str2[pos2 - spl2] = '\0';
      *result = (fnmatch(str2, str1, 0) == 0);
      free(str1);
      free(str2);
    } else
      *result = (result1 == result2);
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, ">=", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(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 (splice_infix(buf, pos1, pos2, ">", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(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 (splice_infix(buf, pos1, pos2, "<=", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(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 (splice_infix(buf, pos1, pos2, "<", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(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 (splice_infix(buf, pos1, pos2, "+", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 + result2;
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, "-", &spl1, &spl2)) {
    if (spl1 != pos1) {
      if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
          !do_arithm_eval(buf, spl2, pos2, &result2))
        return 0;
      *result = result1 - result2;
      return 1;
    }
  }
  if (splice_infix(buf, pos1, pos2, "*", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    *result = result1 * result2;
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, "/", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    if (result2 == 0)
      bug("Division by zero in expression");
    *result = result1 / result2;
    return 1;
  }
  if (splice_infix(buf, pos1, pos2, "%", &spl1, &spl2)) {
    if (!do_arithm_eval(buf, pos1, spl1, &result1) ||
        !do_arithm_eval(buf, spl2, pos2, &result2))
      return 0;
    if (result2 == 0)
      bug("Division by zero in expression");
    *result = result1 % result2;
    return 1;
  }
  if (buf[pos1] == '~') {
    if (!do_arithm_eval(buf, pos1 + 1, pos2, &result1))
      return 0;
    *result = ~result1;
    return 1;
  }
  if (buf[pos1] == '!') {
    if (!do_arithm_eval(buf, pos1 + 1, pos2, &result1))
      return 0;
    *result = !result1;
    return 1;
  }
  if (buf[pos1] == '-') {
    if (!do_arithm_eval(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 do_arithm_eval(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):
<do_arithm_eval>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x51(%rbp)
jge    11e5 <do_arithm_eval+0x45>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    11f5 <do_arithm_eval+0x55>
jmp    1203 <do_arithm_eval+0x63>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11b9 <do_arithm_eval+0x19>
jmp    1208 <do_arithm_eval+0x68>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x52(%rbp)
jge    1239 <do_arithm_eval+0x99>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
test   $0x1,%al
jne    1249 <do_arithm_eval+0xa9>
jmp    1257 <do_arithm_eval+0xb7>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1208 <do_arithm_eval+0x68>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    126f <do_arithm_eval+0xcf>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1d80(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     130e <do_arithm_eval+0x16e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     12cf <do_arithm_eval+0x12f>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    12db <do_arithm_eval+0x13b>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x53(%rbp)
jne    12f4 <do_arithm_eval+0x154>
cmpl   $0x0,-0x30(%rbp)
setne  %al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1ce4(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     13ad <do_arithm_eval+0x20d>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     136e <do_arithm_eval+0x1ce>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    137a <do_arithm_eval+0x1da>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x54(%rbp)
je     1393 <do_arithm_eval+0x1f3>
cmpl   $0x0,-0x30(%rbp)
setne  %al
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1c43(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     1431 <do_arithm_eval+0x291>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     140d <do_arithm_eval+0x26d>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    1419 <do_arithm_eval+0x279>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x2c(%rbp),%ecx
or     -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1bc4(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     14b5 <do_arithm_eval+0x315>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     1491 <do_arithm_eval+0x2f1>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    149d <do_arithm_eval+0x2fd>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x2c(%rbp),%ecx
xor    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1b3e(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     1539 <do_arithm_eval+0x399>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     1515 <do_arithm_eval+0x375>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    1521 <do_arithm_eval+0x381>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x2c(%rbp),%ecx
and    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1abe(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     16b6 <do_arithm_eval+0x516>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     1599 <do_arithm_eval+0x3f9>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    1696 <do_arithm_eval+0x4f6>
jmp    159e <do_arithm_eval+0x3fe>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x55(%rbp)
jge    15cf <do_arithm_eval+0x42f>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
test   $0x1,%al
jne    15df <do_arithm_eval+0x43f>
jmp    15ed <do_arithm_eval+0x44d>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    159e <do_arithm_eval+0x3fe>
jmp    15f2 <do_arithm_eval+0x452>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x56(%rbp)
jle    161e <do_arithm_eval+0x47e>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x56(%rbp)
mov    -0x56(%rbp),%al
test   $0x1,%al
jne    162e <do_arithm_eval+0x48e>
jmp    163c <do_arithm_eval+0x49c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15f2 <do_arithm_eval+0x452>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
je     165f <do_arithm_eval+0x4bf>
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
jmp    1691 <do_arithm_eval+0x4f1>
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   1040 <strncmp@plt>
cmp    $0x0,%eax
setne  %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    16aa <do_arithm_eval+0x50a>
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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1944(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     1833 <do_arithm_eval+0x693>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     1716 <do_arithm_eval+0x576>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    1813 <do_arithm_eval+0x673>
jmp    171b <do_arithm_eval+0x57b>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x57(%rbp)
jge    174c <do_arithm_eval+0x5ac>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x57(%rbp)
mov    -0x57(%rbp),%al
test   $0x1,%al
jne    175c <do_arithm_eval+0x5bc>
jmp    176a <do_arithm_eval+0x5ca>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    171b <do_arithm_eval+0x57b>
jmp    176f <do_arithm_eval+0x5cf>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x58(%rbp)
jle    179b <do_arithm_eval+0x5fb>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x58(%rbp)
mov    -0x58(%rbp),%al
test   $0x1,%al
jne    17ab <do_arithm_eval+0x60b>
jmp    17b9 <do_arithm_eval+0x619>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    176f <do_arithm_eval+0x5cf>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
je     17dc <do_arithm_eval+0x63c>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
jmp    180e <do_arithm_eval+0x66e>
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   1040 <strncmp@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1827 <do_arithm_eval+0x687>
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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x17ca(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     19e4 <do_arithm_eval+0x844>
lea    0x17af(%rip),%rdi
call   1060 <bug@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     189f <do_arithm_eval+0x6ff>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    19c4 <do_arithm_eval+0x824>
jmp    18a4 <do_arithm_eval+0x704>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x59(%rbp)
jge    18d5 <do_arithm_eval+0x735>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    18e5 <do_arithm_eval+0x745>
jmp    18f3 <do_arithm_eval+0x753>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    18a4 <do_arithm_eval+0x704>
jmp    18f8 <do_arithm_eval+0x758>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x5a(%rbp)
jle    1924 <do_arithm_eval+0x784>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x5a(%rbp)
mov    -0x5a(%rbp),%al
test   $0x1,%al
jne    1934 <do_arithm_eval+0x794>
jmp    1942 <do_arithm_eval+0x7a2>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    18f8 <do_arithm_eval+0x758>
mov    -0x10(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
call   10c0 <strdup@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rdi
movslq -0x28(%rbp),%rax
add    %rax,%rdi
call   10c0 <strdup@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
xor    %edx,%edx
call   1090 <fnmatch@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
jmp    19d8 <do_arithm_eval+0x838>
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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1646(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     1b96 <do_arithm_eval+0x9f6>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     1a44 <do_arithm_eval+0x8a4>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    1b76 <do_arithm_eval+0x9d6>
jmp    1a49 <do_arithm_eval+0x8a9>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x5b(%rbp)
jge    1a7a <do_arithm_eval+0x8da>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x5b(%rbp)
mov    -0x5b(%rbp),%al
test   $0x1,%al
jne    1a8a <do_arithm_eval+0x8ea>
jmp    1a98 <do_arithm_eval+0x8f8>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1a49 <do_arithm_eval+0x8a9>
jmp    1a9d <do_arithm_eval+0x8fd>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x5c(%rbp)
jle    1ac9 <do_arithm_eval+0x929>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x5c(%rbp)
mov    -0x5c(%rbp),%al
test   $0x1,%al
jne    1ad9 <do_arithm_eval+0x939>
jmp    1ae7 <do_arithm_eval+0x947>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a9d <do_arithm_eval+0x8fd>
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    1b0a <do_arithm_eval+0x96a>
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   1040 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x5d(%rbp)
jg     1b63 <do_arithm_eval+0x9c3>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x5e(%rbp)
jne    1b5d <do_arithm_eval+0x9bd>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setge  %al
mov    %al,-0x5e(%rbp)
mov    -0x5e(%rbp),%al
mov    %al,-0x5d(%rbp)
mov    -0x5d(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1b8a <do_arithm_eval+0x9ea>
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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1497(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     1d48 <do_arithm_eval+0xba8>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     1bf6 <do_arithm_eval+0xa56>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    1d28 <do_arithm_eval+0xb88>
jmp    1bfb <do_arithm_eval+0xa5b>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x5f(%rbp)
jge    1c2c <do_arithm_eval+0xa8c>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x5f(%rbp)
mov    -0x5f(%rbp),%al
test   $0x1,%al
jne    1c3c <do_arithm_eval+0xa9c>
jmp    1c4a <do_arithm_eval+0xaaa>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1bfb <do_arithm_eval+0xa5b>
jmp    1c4f <do_arithm_eval+0xaaf>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x60(%rbp)
jle    1c7b <do_arithm_eval+0xadb>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x60(%rbp)
mov    -0x60(%rbp),%al
test   $0x1,%al
jne    1c8b <do_arithm_eval+0xaeb>
jmp    1c99 <do_arithm_eval+0xaf9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1c4f <do_arithm_eval+0xaaf>
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    1cbc <do_arithm_eval+0xb1c>
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   1040 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x61(%rbp)
jg     1d15 <do_arithm_eval+0xb75>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x62(%rbp)
jne    1d0f <do_arithm_eval+0xb6f>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setg   %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1d3c <do_arithm_eval+0xb9c>
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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x12e7(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     1efa <do_arithm_eval+0xd5a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     1da8 <do_arithm_eval+0xc08>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    1eda <do_arithm_eval+0xd3a>
jmp    1dad <do_arithm_eval+0xc0d>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x63(%rbp)
jge    1dde <do_arithm_eval+0xc3e>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x63(%rbp)
mov    -0x63(%rbp),%al
test   $0x1,%al
jne    1dee <do_arithm_eval+0xc4e>
jmp    1dfc <do_arithm_eval+0xc5c>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1dad <do_arithm_eval+0xc0d>
jmp    1e01 <do_arithm_eval+0xc61>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x64(%rbp)
jle    1e2d <do_arithm_eval+0xc8d>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x64(%rbp)
mov    -0x64(%rbp),%al
test   $0x1,%al
jne    1e3d <do_arithm_eval+0xc9d>
jmp    1e4b <do_arithm_eval+0xcab>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1e01 <do_arithm_eval+0xc61>
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    1e6e <do_arithm_eval+0xcce>
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   1040 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x65(%rbp)
jl     1ec7 <do_arithm_eval+0xd27>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x66(%rbp)
jne    1ec1 <do_arithm_eval+0xd21>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setle  %al
mov    %al,-0x66(%rbp)
mov    -0x66(%rbp),%al
mov    %al,-0x65(%rbp)
mov    -0x65(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1eee <do_arithm_eval+0xd4e>
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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0x1138(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     20ac <do_arithm_eval+0xf0c>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     1f5a <do_arithm_eval+0xdba>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    208c <do_arithm_eval+0xeec>
jmp    1f5f <do_arithm_eval+0xdbf>
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x67(%rbp)
jge    1f90 <do_arithm_eval+0xdf0>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x67(%rbp)
mov    -0x67(%rbp),%al
test   $0x1,%al
jne    1fa0 <do_arithm_eval+0xe00>
jmp    1fae <do_arithm_eval+0xe0e>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1f5f <do_arithm_eval+0xdbf>
jmp    1fb3 <do_arithm_eval+0xe13>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x68(%rbp)
jle    1fdf <do_arithm_eval+0xe3f>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   10b0 <iswhite@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x68(%rbp)
mov    -0x68(%rbp),%al
test   $0x1,%al
jne    1fef <do_arithm_eval+0xe4f>
jmp    1ffd <do_arithm_eval+0xe5d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1fb3 <do_arithm_eval+0xe13>
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    2020 <do_arithm_eval+0xe80>
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   1040 <strncmp@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x69(%rbp)
jl     2079 <do_arithm_eval+0xed9>
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x6a(%rbp)
jne    2073 <do_arithm_eval+0xed3>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x6a(%rbp)
mov    -0x6a(%rbp),%al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    20a0 <do_arithm_eval+0xf00>
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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xf88(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     2130 <do_arithm_eval+0xf90>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     210c <do_arithm_eval+0xf6c>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    2118 <do_arithm_eval+0xf78>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xf06(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     21c5 <do_arithm_eval+0x1025>
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     21c0 <do_arithm_eval+0x1020>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     219c <do_arithm_eval+0xffc>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    21a8 <do_arithm_eval+0x1008>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x2c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
jmp    21c5 <do_arithm_eval+0x1025>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xe73(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     224a <do_arithm_eval+0x10aa>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     2225 <do_arithm_eval+0x1085>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    2231 <do_arithm_eval+0x1091>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x2c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xdf0(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     22e7 <do_arithm_eval+0x1147>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     22aa <do_arithm_eval+0x110a>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    22b6 <do_arithm_eval+0x1116>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
cmpl   $0x0,-0x30(%rbp)
jne    22cc <do_arithm_eval+0x112c>
lea    0xd86(%rip),%rdi
call   1060 <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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xd74(%rip),%rcx
lea    -0x24(%rbp),%r8
lea    -0x28(%rbp),%r9
call   1050 <splice_infix@plt>
cmp    $0x0,%rax
je     2382 <do_arithm_eval+0x11e2>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
je     2347 <do_arithm_eval+0x11a7>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    -0x30(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    2353 <do_arithm_eval+0x11b3>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
cmpl   $0x0,-0x30(%rbp)
jne    2369 <do_arithm_eval+0x11c9>
lea    0xce9(%rip),%rdi
call   1060 <bug@plt>
mov    -0x2c(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %edx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7e,%eax
jne    23da <do_arithm_eval+0x123a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    23c2 <do_arithm_eval+0x1222>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x2c(%rbp),%ecx
xor    $0xffffffff,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x21,%eax
jne    243a <do_arithm_eval+0x129a>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    241a <do_arithm_eval+0x127a>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
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    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    2491 <do_arithm_eval+0x12f1>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
lea    -0x2c(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
cmp    $0x0,%eax
jne    247a <do_arithm_eval+0x12da>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
xor    %ecx,%ecx
sub    -0x2c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
lea    0xbc7(%rip),%rdi
call   1070 <strlen@plt>
mov    -0x78(%rbp),%rdi
mov    %eax,%edx
lea    0xbb5(%rip),%rsi
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    2519 <do_arithm_eval+0x1379>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     24ed <do_arithm_eval+0x134d>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x7c(%rbp)
lea    0xb79(%rip),%rdi
call   1070 <strlen@plt>
mov    -0x7c(%rbp),%ecx
sub    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    2575 <do_arithm_eval+0x13d5>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     2554 <do_arithm_eval+0x13b4>
movl   $0x0,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
mov    -0x20(%rbp),%rcx
call   1080 <do_arithm_eval@plt>
mov    %eax,-0x4(%rbp)
jmp    25d8 <do_arithm_eval+0x1438>
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   10a0 <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    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<do_arithm_eval>:
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    11fe <do_arithm_eval+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   10b0 <iswhite@plt>
test   %rax,%rax
je     1203 <do_arithm_eval+0x63>
add    $0x1,%rbp
cmp    %rbp,%r15
jne    11e0 <do_arithm_eval+0x40>
mov    %r12d,%esi
jmp    1209 <do_arithm_eval+0x69>
movslq %r12d,%rbx
jmp    1211 <do_arithm_eval+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    123e <do_arithm_eval+0x9e>
movsbl -0x1(%rbp,%rbx,1),%edi
add    $0xffffffffffffffff,%rbx
call   10b0 <iswhite@plt>
test   %rax,%rax
jne    1220 <do_arithm_eval+0x80>
add    $0x1,%ebx
mov    %ebx,%r12d
xor    %r13d,%r13d
mov    0x10(%rsp),%ebx
cmp    %ebx,%r12d
jne    125c <do_arithm_eval+0xbc>
mov    %r13d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xd9d(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     12c6 <do_arithm_eval+0x126>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0x18(%rsp),%eax
xor    %ecx,%ecx
or     0x14(%rsp),%eax
setne  %cl
mov    %ecx,(%r15)
mov    $0x1,%r13d
jmp    124a <do_arithm_eval+0xaa>
lea    0xd36(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     133a <do_arithm_eval+0x19a>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
cmpl   $0x0,0x18(%rsp)
setne  %al
cmpl   $0x0,0x14(%rsp)
setne  %cl
and    %al,%cl
movzbl %cl,%eax
jmp    1467 <do_arithm_eval+0x2c7>
lea    0xcc0(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     13a1 <do_arithm_eval+0x201>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0x14(%rsp),%eax
or     0x18(%rsp),%eax
jmp    1467 <do_arithm_eval+0x2c7>
lea    0xc5e(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1405 <do_arithm_eval+0x265>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0x14(%rsp),%eax
xor    0x18(%rsp),%eax
jmp    1467 <do_arithm_eval+0x2c7>
lea    0xbf8(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1475 <do_arithm_eval+0x2d5>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0x14(%rsp),%eax
and    0x18(%rsp),%eax
mov    %eax,(%r15)
mov    $0x1,%r13d
jmp    124a <do_arithm_eval+0xaa>
lea    0xb8c(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1559 <do_arithm_eval+0x3b9>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     14da <do_arithm_eval+0x33a>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     14da <do_arithm_eval+0x33a>
mov    0x18(%rsp),%eax
xor    %ecx,%ecx
cmp    0x14(%rsp),%eax
jmp    12b8 <do_arithm_eval+0x118>
mov    0x8(%rsp),%eax
cmp    %eax,%ebx
jge    1502 <do_arithm_eval+0x362>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   10b0 <iswhite@plt>
test   %rax,%rax
je     1502 <do_arithm_eval+0x362>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     14e2 <do_arithm_eval+0x342>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r12d
jle    152d <do_arithm_eval+0x38d>
movslq %ecx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   10b0 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     152d <do_arithm_eval+0x38d>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r12d
jg     150b <do_arithm_eval+0x36b>
mov    0x8(%rsp),%edx
sub    %ebx,%edx
sub    %ecx,%r12d
cmp    %r12d,%edx
jne    1635 <do_arithm_eval+0x495>
add    %rbp,%r14
movslq %ecx,%rsi
add    %rbp,%rsi
mov    %r14,%rdi
call   1040 <strncmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
jmp    12b8 <do_arithm_eval+0x118>
lea    0xaab(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1647 <do_arithm_eval+0x4a7>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     15b3 <do_arithm_eval+0x413>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
jne    16a9 <do_arithm_eval+0x509>
mov    0x8(%rsp),%eax
cmp    %eax,%ebx
jge    15db <do_arithm_eval+0x43b>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   10b0 <iswhite@plt>
test   %rax,%rax
je     15db <do_arithm_eval+0x43b>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     15bb <do_arithm_eval+0x41b>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r12d
jle    1606 <do_arithm_eval+0x466>
movslq %ecx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   10b0 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1606 <do_arithm_eval+0x466>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r12d
jg     15e4 <do_arithm_eval+0x444>
mov    0x8(%rsp),%edx
sub    %ebx,%edx
sub    %ecx,%r12d
cmp    %r12d,%edx
jne    16bb <do_arithm_eval+0x51b>
add    %rbp,%r14
movslq %ecx,%rsi
add    %rbp,%rsi
mov    %r14,%rdi
call   1040 <strncmp@plt>
xor    %ecx,%ecx
test   %eax,%eax
sete   %cl
jmp    12bb <do_arithm_eval+0x11b>
movl   $0x1,(%r15)
mov    $0x1,%r13d
jmp    124a <do_arithm_eval+0xaa>
lea    0x9c0(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     178c <do_arithm_eval+0x5ec>
lea    0x99c(%rip),%rdi
call   1060 <bug@plt>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     16cd <do_arithm_eval+0x52d>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     16cd <do_arithm_eval+0x52d>
mov    0x18(%rsp),%eax
xor    %ecx,%ecx
cmp    0x14(%rsp),%eax
sete   %cl
jmp    12bb <do_arithm_eval+0x11b>
movl   $0x0,(%r15)
mov    $0x1,%r13d
jmp    124a <do_arithm_eval+0xaa>
mov    0x8(%rsp),%eax
cmp    %eax,%ebx
jge    16f5 <do_arithm_eval+0x555>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   10b0 <iswhite@plt>
test   %rax,%rax
je     16f5 <do_arithm_eval+0x555>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     16d5 <do_arithm_eval+0x535>
mov    0xc(%rsp),%ebx
mov    %r15,%r13
cmp    %ebx,%r12d
jle    1723 <do_arithm_eval+0x583>
movslq %ebx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   10b0 <iswhite@plt>
mov    0xc(%rsp),%ebx
test   %rax,%rax
je     1723 <do_arithm_eval+0x583>
add    $0x1,%ebx
mov    %ebx,0xc(%rsp)
cmp    %ebx,%r12d
jg     1701 <do_arithm_eval+0x561>
lea    (%r14,%rbp,1),%rdi
call   10c0 <strdup@plt>
mov    %rax,%r15
movslq 0x8(%rsp),%rax
sub    %r14,%rax
movb   $0x0,(%r15,%rax,1)
movslq %ebx,%rbx
add    %rbx,%rbp
mov    %rbp,%rdi
call   10c0 <strdup@plt>
mov    %rax,%rbp
sub    %ebx,%r12d
movslq %r12d,%rax
movb   $0x0,0x0(%rbp,%rax,1)
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %edx,%edx
call   1090 <fnmatch@plt>
xor    %ecx,%ecx
test   %rax,%rax
sete   %cl
mov    %ecx,0x0(%r13)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    $0x1,%r13d
jmp    124a <do_arithm_eval+0xaa>
lea    0x8a8(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     188f <do_arithm_eval+0x6ef>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     17f2 <do_arithm_eval+0x652>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     17f2 <do_arithm_eval+0x652>
mov    0x18(%rsp),%eax
cmp    0x14(%rsp),%eax
setge  %cl
jmp    1a20 <do_arithm_eval+0x880>
mov    %r15,%r13
mov    0x8(%rsp),%eax
cmp    %eax,%ebx
jge    181d <do_arithm_eval+0x67d>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   10b0 <iswhite@plt>
test   %rax,%rax
je     181d <do_arithm_eval+0x67d>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     17fd <do_arithm_eval+0x65d>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r12d
jle    1848 <do_arithm_eval+0x6a8>
movslq %ecx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   10b0 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1848 <do_arithm_eval+0x6a8>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r12d
jg     1826 <do_arithm_eval+0x686>
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   1040 <strncmp@plt>
mov    %eax,0x18(%rsp)
mov    $0x1,%cl
test   %eax,%eax
mov    %r13,%r15
jg     1a20 <do_arithm_eval+0x880>
je     1a0c <do_arithm_eval+0x86c>
xor    %ecx,%ecx
jmp    1a1d <do_arithm_eval+0x87d>
mov    %r15,0x20(%rsp)
lea    0x7a3(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r12d,%r15d
mov    %r12d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     19a1 <do_arithm_eval+0x801>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %rbp,%rdi
mov    %ebx,%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     18fa <do_arithm_eval+0x75a>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %rbp,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     18fa <do_arithm_eval+0x75a>
mov    0x18(%rsp),%eax
cmp    0x14(%rsp),%eax
jmp    1999 <do_arithm_eval+0x7f9>
mov    0x8(%rsp),%eax
mov    0x10(%rsp),%ebx
cmp    %eax,%ebx
jge    1926 <do_arithm_eval+0x786>
cltq
movsbl -0x1(%rax,%rbp,1),%edi
call   10b0 <iswhite@plt>
test   %rax,%rax
je     1926 <do_arithm_eval+0x786>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,%ebx
jl     1906 <do_arithm_eval+0x766>
mov    0xc(%rsp),%ecx
mov    %r15d,%ebx
cmp    %ecx,%r15d
jle    1953 <do_arithm_eval+0x7b3>
movslq %ecx,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   10b0 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1953 <do_arithm_eval+0x7b3>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%ebx
jg     1932 <do_arithm_eval+0x792>
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   1040 <strncmp@plt>
mov    %eax,0x18(%rsp)
mov    $0x1,%cl
test   %eax,%eax
jg     1bc8 <do_arithm_eval+0xa28>
jne    1bc6 <do_arithm_eval+0xa26>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
sub    0xc(%rsp),%r15d
cmp    %r15d,%eax
setg   %cl
jmp    1bc8 <do_arithm_eval+0xa28>
lea    0x698(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %rbp,%r12
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r15d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1ad1 <do_arithm_eval+0x931>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     1a28 <do_arithm_eval+0x888>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     1a28 <do_arithm_eval+0x888>
mov    0x18(%rsp),%eax
cmp    0x14(%rsp),%eax
setle  %cl
jmp    1bc8 <do_arithm_eval+0xa28>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
sub    0xc(%rsp),%ebx
cmp    %ebx,%eax
setge  %cl
mov    %r13,%r15
movzbl %cl,%eax
jmp    1467 <do_arithm_eval+0x2c7>
mov    0x8(%rsp),%eax
cmp    %eax,0x10(%rsp)
jge    1a57 <do_arithm_eval+0x8b7>
mov    %r12,%rbx
cltq
movsbl -0x1(%rax,%rbx,1),%edi
call   10b0 <iswhite@plt>
test   %rax,%rax
je     1a57 <do_arithm_eval+0x8b7>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,0x10(%rsp)
jl     1a35 <do_arithm_eval+0x895>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r15d
jle    1a82 <do_arithm_eval+0x8e2>
movslq %ecx,%rax
movsbl (%r12,%rax,1),%edi
call   10b0 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1a82 <do_arithm_eval+0x8e2>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r15d
jg     1a60 <do_arithm_eval+0x8c0>
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   1040 <strncmp@plt>
mov    %eax,0x18(%rsp)
mov    $0x1,%cl
test   %eax,%eax
js     1bc8 <do_arithm_eval+0xa28>
jne    1bc6 <do_arithm_eval+0xa26>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
sub    0xc(%rsp),%r15d
cmp    %r15d,%eax
setle  %cl
jmp    1bc8 <do_arithm_eval+0xa28>
lea    0x56b(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1bdd <do_arithm_eval+0xa3d>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     1b3b <do_arithm_eval+0x99b>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     1b3b <do_arithm_eval+0x99b>
mov    0x18(%rsp),%eax
cmp    0x14(%rsp),%eax
setl   %cl
jmp    1bc8 <do_arithm_eval+0xa28>
mov    0x8(%rsp),%eax
cmp    %eax,0x10(%rsp)
jge    1b68 <do_arithm_eval+0x9c8>
cltq
movsbl -0x1(%rax,%r12,1),%edi
call   10b0 <iswhite@plt>
test   %rax,%rax
je     1b68 <do_arithm_eval+0x9c8>
mov    0x8(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x8(%rsp)
cmp    %eax,0x10(%rsp)
jl     1b45 <do_arithm_eval+0x9a5>
mov    0xc(%rsp),%ecx
cmp    %ecx,%r15d
jle    1b93 <do_arithm_eval+0x9f3>
movslq %ecx,%rax
movsbl (%r12,%rax,1),%edi
call   10b0 <iswhite@plt>
mov    0xc(%rsp),%ecx
test   %rax,%rax
je     1b93 <do_arithm_eval+0x9f3>
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
cmp    %ecx,%r15d
jg     1b71 <do_arithm_eval+0x9d1>
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   1040 <strncmp@plt>
mov    %eax,0x18(%rsp)
mov    $0x1,%cl
test   %eax,%eax
js     1bc8 <do_arithm_eval+0xa28>
je     1cf5 <do_arithm_eval+0xb55>
xor    %ecx,%ecx
movzbl %cl,%eax
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
mov    $0x1,%r13d
jmp    124a <do_arithm_eval+0xaa>
lea    0x461(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1c4d <do_arithm_eval+0xaad>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     124a <do_arithm_eval+0xaa>
mov    0x14(%rsp),%eax
add    0x18(%rsp),%eax
jmp    1467 <do_arithm_eval+0x2c7>
lea    0x3f3(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1c80 <do_arithm_eval+0xae0>
mov    0x8(%rsp),%edx
cmp    0x10(%rsp),%edx
jne    1d0d <do_arithm_eval+0xb6d>
lea    0x3c2(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1d54 <do_arithm_eval+0xbb4>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     124a <do_arithm_eval+0xaa>
mov    0x14(%rsp),%eax
imul   0x18(%rsp),%eax
jmp    1467 <do_arithm_eval+0x2c7>
mov    0x8(%rsp),%eax
sub    0x10(%rsp),%eax
sub    0xc(%rsp),%r15d
cmp    %r15d,%eax
setl   %cl
jmp    1bc8 <do_arithm_eval+0xa28>
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     124a <do_arithm_eval+0xaa>
mov    0x18(%rsp),%eax
sub    0x14(%rsp),%eax
jmp    1467 <do_arithm_eval+0x2c7>
lea    0x2f0(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1dd6 <do_arithm_eval+0xc36>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
jne    1dca <do_arithm_eval+0xc2a>
lea    0x28c(%rip),%rdi
call   1060 <bug@plt>
mov    0x14(%rsp),%ecx
mov    0x18(%rsp),%eax
cltd
idiv   %ecx
jmp    1bcb <do_arithm_eval+0xa2b>
lea    0x28f(%rip),%rcx
lea    0x8(%rsp),%r8
lea    0xc(%rsp),%r9
mov    %r12,%rdi
mov    0x10(%rsp),%esi
mov    %r15d,%edx
call   1050 <splice_infix@plt>
test   %rax,%rax
je     1e65 <do_arithm_eval+0xcc5>
mov    0x8(%rsp),%edx
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%esi
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0xc(%rsp),%esi
lea    0x14(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
je     124a <do_arithm_eval+0xaa>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
jne    1e4c <do_arithm_eval+0xcac>
lea    0x20a(%rip),%rdi
call   1060 <bug@plt>
mov    0x14(%rsp),%ecx
mov    0x18(%rsp),%eax
cltd
idiv   %ecx
mov    0x20(%rsp),%rax
mov    %edx,(%rax)
mov    $0x1,%r13d
jmp    124a <do_arithm_eval+0xaa>
mov    (%r12,%r14,1),%al
cmp    $0x21,%al
je     1ea8 <do_arithm_eval+0xd08>
cmp    $0x2d,%al
je     1edb <do_arithm_eval+0xd3b>
cmp    $0x7e,%al
jne    1f0a <do_arithm_eval+0xd6a>
mov    0x10(%rsp),%esi
add    $0x1,%esi
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     124a <do_arithm_eval+0xaa>
mov    0x18(%rsp),%eax
not    %eax
jmp    1467 <do_arithm_eval+0x2c7>
mov    0x10(%rsp),%esi
add    $0x1,%esi
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     124a <do_arithm_eval+0xaa>
xor    %eax,%eax
cmpl   $0x0,0x18(%rsp)
sete   %al
jmp    1467 <do_arithm_eval+0x2c7>
mov    0x10(%rsp),%esi
add    $0x1,%esi
lea    0x18(%rsp),%rcx
mov    %r12,%rdi
mov    %r15d,%edx
call   1080 <do_arithm_eval@plt>
test   %eax,%eax
mov    0x20(%rsp),%r15
je     124a <do_arithm_eval+0xaa>
xor    %eax,%eax
sub    0x18(%rsp),%eax
jmp    1467 <do_arithm_eval+0x2c7>
add    %r12,%r14
lea    0x15a(%rip),%rbx
mov    %rbx,%rdi
call   1070 <strlen@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1f62 <do_arithm_eval+0xdc2>
cmpb   $0x28,(%r14)
jne    1f99 <do_arithm_eval+0xdf9>
movslq %r15d,%rdx
cmpb   $0x29,-0x1(%r12,%rdx,1)
mov    0x20(%rsp),%rcx
jne    124a <do_arithm_eval+0xaa>
add    $0xffffffffffffffff,%rdx
mov    0x10(%rsp),%esi
add    $0x1,%esi
mov    %r12,%rdi
call   1080 <do_arithm_eval@plt>
mov    %eax,%r13d
jmp    124a <do_arithm_eval+0xaa>
movslq %r15d,%rax
cmpb   $0x29,-0x1(%rax,%r12,1)
mov    0x20(%rsp),%rbx
jne    124a <do_arithm_eval+0xaa>
lea    0xf9(%rip),%rdi
call   1070 <strlen@plt>
mov    0x10(%rsp),%ecx
add    %eax,%ecx
sub    %ecx,%r15d
mov    %r15d,(%rbx)
mov    $0x1,%r13d
jmp    124a <do_arithm_eval+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   10a0 <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    124a <do_arithm_eval+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 @do_arithm_eval(i8* %0, i32 %1, i32 %2, i32* %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8
%16 = alloca i8*
%17 = alloca i8*
%18 = alloca i8*
store i8* %0, i8** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32* %3, i32** %9
br label %19
19: ; preds = %33, %4
%20 = load i32, i32* %7
%21 = load i32, i32* %8
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %31
23: ; preds = %19
%24 = load i8*, i8** %6
%25 = load i32, i32* %7
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8, i8* %24, i64 %26
%28 = load i8, i8* %27
%29 = call i64 @iswhite(i8 signext %28)
%30 = icmp ne i64 %29, 0
br label %31
31: ; preds = %23, %19
%32 = phi i1 [ false, %19 ], [ %30, %23 ]
br i1 %32, label %33, label %36
33: ; preds = %31
%34 = load i32, i32* %7
%35 = add nsw i32 %34, 1
store i32 %35, i32* %7
br label %19
36: ; preds = %31
br label %37
37: ; preds = %52, %36
%38 = load i32, i32* %7
%39 = load i32, i32* %8
%40 = icmp slt i32 %38, %39
br i1 %40, label %41, label %50
41: ; preds = %37
%42 = load i8*, i8** %6
%43 = load i32, i32* %8
%44 = sub nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %42, i64 %45
%47 = load i8, i8* %46
%48 = call i64 @iswhite(i8 signext %47)
%49 = icmp ne i64 %48, 0
br label %50
50: ; preds = %41, %37
%51 = phi i1 [ false, %37 ], [ %49, %41 ]
br i1 %51, label %52, label %55
52: ; preds = %50
%53 = load i32, i32* %8
%54 = add nsw i32 %53, -1
store i32 %54, i32* %8
br label %37
55: ; preds = %50
%56 = load i32, i32* %7
%57 = load i32, i32* %8
%58 = icmp eq i32 %56, %57
br i1 %58, label %59, label %60
59: ; preds = %55
store i32 0, i32* %5
br label %1161
60: ; preds = %55
%61 = load i8*, i8** %6
%62 = load i32, i32* %7
%63 = load i32, i32* %8
%64 = call i64 @splice_infix(i8* %61, i32 %62, i32 %63, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %10, i32* %11)
%65 = icmp ne i64 %64, 0
br i1 %65, label %66, label %89
66: ; preds = %60
%67 = load i8*, i8** %6
%68 = load i32, i32* %7
%69 = load i32, i32* %10
%70 = call i32 @do_arithm_eval(i8* %67, i32 %68, i32 %69, i32* %12)
%71 = icmp ne i32 %70, 0
br i1 %71, label %72, label %78
72: ; preds = %66
%73 = load i8*, i8** %6
%74 = load i32, i32* %11
%75 = load i32, i32* %8
%76 = call i32 @do_arithm_eval(i8* %73, i32 %74, i32 %75, i32* %13)
%77 = icmp ne i32 %76, 0
br i1 %77, label %79, label %78
78: ; preds = %72, %66
store i32 0, i32* %5
br label %1161
79: ; preds = %72
%80 = load i32, i32* %12
%81 = icmp ne i32 %80, 0
br i1 %81, label %85, label %82
82: ; preds = %79
%83 = load i32, i32* %13
%84 = icmp ne i32 %83, 0
br label %85
85: ; preds = %82, %79
%86 = phi i1 [ true, %79 ], [ %84, %82 ]
%87 = zext i1 %86 to i32
%88 = load i32*, i32** %9
store i32 %87, i32* %88
store i32 1, i32* %5
br label %1161
89: ; preds = %60
%90 = load i8*, i8** %6
%91 = load i32, i32* %7
%92 = load i32, i32* %8
%93 = call i64 @splice_infix(i8* %90, i32 %91, i32 %92, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %10, i32* %11)
%94 = icmp ne i64 %93, 0
br i1 %94, label %95, label %118
95: ; preds = %89
%96 = load i8*, i8** %6
%97 = load i32, i32* %7
%98 = load i32, i32* %10
%99 = call i32 @do_arithm_eval(i8* %96, i32 %97, i32 %98, i32* %12)
%100 = icmp ne i32 %99, 0
br i1 %100, label %101, label %107
101: ; preds = %95
%102 = load i8*, i8** %6
%103 = load i32, i32* %11
%104 = load i32, i32* %8
%105 = call i32 @do_arithm_eval(i8* %102, i32 %103, i32 %104, i32* %13)
%106 = icmp ne i32 %105, 0
br i1 %106, label %108, label %107
107: ; preds = %101, %95
store i32 0, i32* %5
br label %1161
108: ; preds = %101
%109 = load i32, i32* %12
%110 = icmp ne i32 %109, 0
br i1 %110, label %111, label %114
111: ; preds = %108
%112 = load i32, i32* %13
%113 = icmp ne i32 %112, 0
br label %114
114: ; preds = %111, %108
%115 = phi i1 [ false, %108 ], [ %113, %111 ]
%116 = zext i1 %115 to i32
%117 = load i32*, i32** %9
store i32 %116, i32* %117
store i32 1, i32* %5
br label %1161
118: ; preds = %89
%119 = load i8*, i8** %6
%120 = load i32, i32* %7
%121 = load i32, i32* %8
%122 = call i64 @splice_infix(i8* %119, i32 %120, i32 %121, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32* %10, i32* %11)
%123 = icmp ne i64 %122, 0
br i1 %123, label %124, label %142
124: ; preds = %118
%125 = load i8*, i8** %6
%126 = load i32, i32* %7
%127 = load i32, i32* %10
%128 = call i32 @do_arithm_eval(i8* %125, i32 %126, i32 %127, i32* %12)
%129 = icmp ne i32 %128, 0
br i1 %129, label %130, label %136
130: ; preds = %124
%131 = load i8*, i8** %6
%132 = load i32, i32* %11
%133 = load i32, i32* %8
%134 = call i32 @do_arithm_eval(i8* %131, i32 %132, i32 %133, i32* %13)
%135 = icmp ne i32 %134, 0
br i1 %135, label %137, label %136
136: ; preds = %130, %124
store i32 0, i32* %5
br label %1161
137: ; preds = %130
%138 = load i32, i32* %12
%139 = load i32, i32* %13
%140 = or i32 %138, %139
%141 = load i32*, i32** %9
store i32 %140, i32* %141
store i32 1, i32* %5
br label %1161
142: ; preds = %118
%143 = load i8*, i8** %6
%144 = load i32, i32* %7
%145 = load i32, i32* %8
%146 = call i64 @splice_infix(i8* %143, i32 %144, i32 %145, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), i32* %10, i32* %11)
%147 = icmp ne i64 %146, 0
br i1 %147, label %148, label %166
148: ; preds = %142
%149 = load i8*, i8** %6
%150 = load i32, i32* %7
%151 = load i32, i32* %10
%152 = call i32 @do_arithm_eval(i8* %149, i32 %150, i32 %151, i32* %12)
%153 = icmp ne i32 %152, 0
br i1 %153, label %154, label %160
154: ; preds = %148
%155 = load i8*, i8** %6
%156 = load i32, i32* %11
%157 = load i32, i32* %8
%158 = call i32 @do_arithm_eval(i8* %155, i32 %156, i32 %157, i32* %13)
%159 = icmp ne i32 %158, 0
br i1 %159, label %161, label %160
160: ; preds = %154, %148
store i32 0, i32* %5
br label %1161
161: ; preds = %154
%162 = load i32, i32* %12
%163 = load i32, i32* %13
%164 = xor i32 %162, %163
%165 = load i32*, i32** %9
store i32 %164, i32* %165
store i32 1, i32* %5
br label %1161
166: ; preds = %142
%167 = load i8*, i8** %6
%168 = load i32, i32* %7
%169 = load i32, i32* %8
%170 = call i64 @splice_infix(i8* %167, i32 %168, i32 %169, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i32* %10, i32* %11)
%171 = icmp ne i64 %170, 0
br i1 %171, label %172, label %190
172: ; preds = %166
%173 = load i8*, i8** %6
%174 = load i32, i32* %7
%175 = load i32, i32* %10
%176 = call i32 @do_arithm_eval(i8* %173, i32 %174, i32 %175, i32* %12)
%177 = icmp ne i32 %176, 0
br i1 %177, label %178, label %184
178: ; preds = %172
%179 = load i8*, i8** %6
%180 = load i32, i32* %11
%181 = load i32, i32* %8
%182 = call i32 @do_arithm_eval(i8* %179, i32 %180, i32 %181, i32* %13)
%183 = icmp ne i32 %182, 0
br i1 %183, label %185, label %184
184: ; preds = %178, %172
store i32 0, i32* %5
br label %1161
185: ; preds = %178
%186 = load i32, i32* %12
%187 = load i32, i32* %13
%188 = and i32 %186, %187
%189 = load i32*, i32** %9
store i32 %188, i32* %189
store i32 1, i32* %5
br label %1161
190: ; preds = %166
%191 = load i8*, i8** %6
%192 = load i32, i32* %7
%193 = load i32, i32* %8
%194 = call i64 @splice_infix(i8* %191, i32 %192, i32 %193, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32* %10, i32* %11)
%195 = icmp ne i64 %194, 0
br i1 %195, label %196, label %279
196: ; preds = %190
%197 = load i8*, i8** %6
%198 = load i32, i32* %7
%199 = load i32, i32* %10
%200 = call i32 @do_arithm_eval(i8* %197, i32 %198, i32 %199, i32* %12)
%201 = icmp ne i32 %200, 0
br i1 %201, label %202, label %208
202: ; preds = %196
%203 = load i8*, i8** %6
%204 = load i32, i32* %11
%205 = load i32, i32* %8
%206 = call i32 @do_arithm_eval(i8* %203, i32 %204, i32 %205, i32* %13)
%207 = icmp ne i32 %206, 0
br i1 %207, label %272, label %208
208: ; preds = %202, %196
br label %209
209: ; preds = %224, %208
%210 = load i32, i32* %7
%211 = load i32, i32* %10
%212 = icmp slt i32 %210, %211
br i1 %212, label %213, label %222
213: ; preds = %209
%214 = load i8*, i8** %6
%215 = load i32, i32* %10
%216 = sub nsw i32 %215, 1
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i8, i8* %214, i64 %217
%219 = load i8, i8* %218
%220 = call i64 @iswhite(i8 signext %219)
%221 = icmp ne i64 %220, 0
br label %222
222: ; preds = %213, %209
%223 = phi i1 [ false, %209 ], [ %221, %213 ]
br i1 %223, label %224, label %227
224: ; preds = %222
%225 = load i32, i32* %10
%226 = add nsw i32 %225, -1
store i32 %226, i32* %10
br label %209
227: ; preds = %222
br label %228
228: ; preds = %242, %227
%229 = load i32, i32* %8
%230 = load i32, i32* %11
%231 = icmp sgt i32 %229, %230
br i1 %231, label %232, label %240
232: ; preds = %228
%233 = load i8*, i8** %6
%234 = load i32, i32* %11
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i8, i8* %233, i64 %235
%237 = load i8, i8* %236
%238 = call i64 @iswhite(i8 signext %237)
%239 = icmp ne i64 %238, 0
br label %240
240: ; preds = %232, %228
%241 = phi i1 [ false, %228 ], [ %239, %232 ]
br i1 %241, label %242, label %245
242: ; preds = %240
%243 = load i32, i32* %11
%244 = add nsw i32 %243, 1
store i32 %244, i32* %11
br label %228
245: ; preds = %240
%246 = load i32, i32* %10
%247 = load i32, i32* %7
%248 = sub nsw i32 %246, %247
%249 = load i32, i32* %8
%250 = load i32, i32* %11
%251 = sub nsw i32 %249, %250
%252 = icmp ne i32 %248, %251
br i1 %252, label %253, label %255
253: ; preds = %245
%254 = load i32*, i32** %9
store i32 1, i32* %254
br label %271
255: ; preds = %245
%256 = load i8*, i8** %6
%257 = load i32, i32* %7
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i8, i8* %256, i64 %258
%260 = load i8*, i8** %6
%261 = load i32, i32* %11
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i8, i8* %260, i64 %262
%264 = load i32, i32* %10
%265 = load i32, i32* %7
%266 = sub nsw i32 %264, %265
%267 = call i32 @strncmp(i8* %259, i8* %263, i32 %266)
%268 = icmp ne i32 %267, 0
%269 = zext i1 %268 to i32
%270 = load i32*, i32** %9
store i32 %269, i32* %270
br label %271
271: ; preds = %255, %253
br label %278
272: ; preds = %202
%273 = load i32, i32* %12
%274 = load i32, i32* %13
%275 = icmp ne i32 %273, %274
%276 = zext i1 %275 to i32
%277 = load i32*, i32** %9
store i32 %276, i32* %277
br label %278
278: ; preds = %272, %271
store i32 1, i32* %5
br label %1161
279: ; preds = %190
%280 = load i8*, i8** %6
%281 = load i32, i32* %7
%282 = load i32, i32* %8
%283 = call i64 @splice_infix(i8* %280, i32 %281, i32 %282, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), i32* %10, i32* %11)
%284 = icmp ne i64 %283, 0
br i1 %284, label %285, label %368
285: ; preds = %279
%286 = load i8*, i8** %6
%287 = load i32, i32* %7
%288 = load i32, i32* %10
%289 = call i32 @do_arithm_eval(i8* %286, i32 %287, i32 %288, i32* %12)
%290 = icmp ne i32 %289, 0
br i1 %290, label %291, label %297
291: ; preds = %285
%292 = load i8*, i8** %6
%293 = load i32, i32* %11
%294 = load i32, i32* %8
%295 = call i32 @do_arithm_eval(i8* %292, i32 %293, i32 %294, i32* %13)
%296 = icmp ne i32 %295, 0
br i1 %296, label %361, label %297
297: ; preds = %291, %285
br label %298
298: ; preds = %313, %297
%299 = load i32, i32* %7
%300 = load i32, i32* %10
%301 = icmp slt i32 %299, %300
br i1 %301, label %302, label %311
302: ; preds = %298
%303 = load i8*, i8** %6
%304 = load i32, i32* %10
%305 = sub nsw i32 %304, 1
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds i8, i8* %303, i64 %306
%308 = load i8, i8* %307
%309 = call i64 @iswhite(i8 signext %308)
%310 = icmp ne i64 %309, 0
br label %311
311: ; preds = %302, %298
%312 = phi i1 [ false, %298 ], [ %310, %302 ]
br i1 %312, label %313, label %316
313: ; preds = %311
%314 = load i32, i32* %10
%315 = add nsw i32 %314, -1
store i32 %315, i32* %10
br label %298
316: ; preds = %311
br label %317
317: ; preds = %331, %316
%318 = load i32, i32* %8
%319 = load i32, i32* %11
%320 = icmp sgt i32 %318, %319
br i1 %320, label %321, label %329
321: ; preds = %317
%322 = load i8*, i8** %6
%323 = load i32, i32* %11
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i8, i8* %322, i64 %324
%326 = load i8, i8* %325
%327 = call i64 @iswhite(i8 signext %326)
%328 = icmp ne i64 %327, 0
br label %329
329: ; preds = %321, %317
%330 = phi i1 [ false, %317 ], [ %328, %321 ]
br i1 %330, label %331, label %334
331: ; preds = %329
%332 = load i32, i32* %11
%333 = add nsw i32 %332, 1
store i32 %333, i32* %11
br label %317
334: ; preds = %329
%335 = load i32, i32* %10
%336 = load i32, i32* %7
%337 = sub nsw i32 %335, %336
%338 = load i32, i32* %8
%339 = load i32, i32* %11
%340 = sub nsw i32 %338, %339
%341 = icmp ne i32 %337, %340
br i1 %341, label %342, label %344
342: ; preds = %334
%343 = load i32*, i32** %9
store i32 0, i32* %343
br label %360
344: ; preds = %334
%345 = load i8*, i8** %6
%346 = load i32, i32* %7
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds i8, i8* %345, i64 %347
%349 = load i8*, i8** %6
%350 = load i32, i32* %11
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i8, i8* %349, i64 %351
%353 = load i32, i32* %10
%354 = load i32, i32* %7
%355 = sub nsw i32 %353, %354
%356 = call i32 @strncmp(i8* %348, i8* %352, i32 %355)
%357 = icmp eq i32 %356, 0
%358 = zext i1 %357 to i32
%359 = load i32*, i32** %9
store i32 %358, i32* %359
br label %360
360: ; preds = %344, %342
br label %367
361: ; preds = %291
%362 = load i32, i32* %12
%363 = load i32, i32* %13
%364 = icmp eq i32 %362, %363
%365 = zext i1 %364 to i32
%366 = load i32*, i32** %9
store i32 %365, i32* %366
br label %367
367: ; preds = %361, %360
store i32 1, i32* %5
br label %1161
368: ; preds = %279
%369 = load i8*, i8** %6
%370 = load i32, i32* %7
%371 = load i32, i32* %8
%372 = call i64 @splice_infix(i8* %369, i32 %370, i32 %371, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32* %10, i32* %11)
%373 = icmp ne i64 %372, 0
br i1 %373, label %374, label %464
374: ; preds = %368
%375 = call i32 @bug(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.8, i64 0, i64 0))
%376 = load i8*, i8** %6
%377 = load i32, i32* %7
%378 = load i32, i32* %10
%379 = call i32 @do_arithm_eval(i8* %376, i32 %377, i32 %378, i32* %12)
%380 = icmp ne i32 %379, 0
br i1 %380, label %381, label %387
381: ; preds = %374
%382 = load i8*, i8** %6
%383 = load i32, i32* %11
%384 = load i32, i32* %8
%385 = call i32 @do_arithm_eval(i8* %382, i32 %383, i32 %384, i32* %13)
%386 = icmp ne i32 %385, 0
br i1 %386, label %457, label %387
387: ; preds = %381, %374
br label %388
388: ; preds = %403, %387
%389 = load i32, i32* %7
%390 = load i32, i32* %10
%391 = icmp slt i32 %389, %390
br i1 %391, label %392, label %401
392: ; preds = %388
%393 = load i8*, i8** %6
%394 = load i32, i32* %10
%395 = sub nsw i32 %394, 1
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds i8, i8* %393, i64 %396
%398 = load i8, i8* %397
%399 = call i64 @iswhite(i8 signext %398)
%400 = icmp ne i64 %399, 0
br label %401
401: ; preds = %392, %388
%402 = phi i1 [ false, %388 ], [ %400, %392 ]
br i1 %402, label %403, label %406
403: ; preds = %401
%404 = load i32, i32* %10
%405 = add nsw i32 %404, -1
store i32 %405, i32* %10
br label %388
406: ; preds = %401
br label %407
407: ; preds = %421, %406
%408 = load i32, i32* %8
%409 = load i32, i32* %11
%410 = icmp sgt i32 %408, %409
br i1 %410, label %411, label %419
411: ; preds = %407
%412 = load i8*, i8** %6
%413 = load i32, i32* %11
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds i8, i8* %412, i64 %414
%416 = load i8, i8* %415
%417 = call i64 @iswhite(i8 signext %416)
%418 = icmp ne i64 %417, 0
br label %419
419: ; preds = %411, %407
%420 = phi i1 [ false, %407 ], [ %418, %411 ]
br i1 %420, label %421, label %424
421: ; preds = %419
%422 = load i32, i32* %11
%423 = add nsw i32 %422, 1
store i32 %423, i32* %11
br label %407
424: ; preds = %419
%425 = load i8*, i8** %6
%426 = load i32, i32* %7
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds i8, i8* %425, i64 %427
%429 = call i8* @strdup(i8* %428)
store i8* %429, i8** %17
%430 = load i8*, i8** %17
%431 = load i32, i32* %10
%432 = load i32, i32* %7
%433 = sub nsw i32 %431, %432
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds i8, i8* %430, i64 %434
store i8 0, i8* %435
%436 = load i8*, i8** %6
%437 = load i32, i32* %11
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds i8, i8* %436, i64 %438
%440 = call i8* @strdup(i8* %439)
store i8* %440, i8** %18
%441 = load i8*, i8** %18
%442 = load i32, i32* %8
%443 = load i32, i32* %11
%444 = sub nsw i32 %442, %443
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds i8, i8* %441, i64 %445
store i8 0, i8* %446
%447 = load i8*, i8** %18
%448 = load i8*, i8** %17
%449 = call i64 @fnmatch(i8* %447, i8* %448, i32 0)
%450 = icmp eq i64 %449, 0
%451 = zext i1 %450 to i32
%452 = load i32*, i32** %9
store i32 %451, i32* %452
%453 = load i8*, i8** %17
%454 = call i32 @free(i8* %453)
%455 = load i8*, i8** %18
%456 = call i32 @free(i8* %455)
br label %463
457: ; preds = %381
%458 = load i32, i32* %12
%459 = load i32, i32* %13
%460 = icmp eq i32 %458, %459
%461 = zext i1 %460 to i32
%462 = load i32*, i32** %9
store i32 %461, i32* %462
br label %463
463: ; preds = %457, %424
store i32 1, i32* %5
br label %1161
464: ; preds = %368
%465 = load i8*, i8** %6
%466 = load i32, i32* %7
%467 = load i32, i32* %8
%468 = call i64 @splice_infix(i8* %465, i32 %466, i32 %467, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0), i32* %10, i32* %11)
%469 = icmp ne i64 %468, 0
br i1 %469, label %470, label %569
470: ; preds = %464
%471 = load i8*, i8** %6
%472 = load i32, i32* %7
%473 = load i32, i32* %10
%474 = call i32 @do_arithm_eval(i8* %471, i32 %472, i32 %473, i32* %12)
%475 = icmp ne i32 %474, 0
br i1 %475, label %476, label %482
476: ; preds = %470
%477 = load i8*, i8** %6
%478 = load i32, i32* %11
%479 = load i32, i32* %8
%480 = call i32 @do_arithm_eval(i8* %477, i32 %478, i32 %479, i32* %13)
%481 = icmp ne i32 %480, 0
br i1 %481, label %562, label %482
482: ; preds = %476, %470
br label %483
483: ; preds = %498, %482
%484 = load i32, i32* %7
%485 = load i32, i32* %10
%486 = icmp slt i32 %484, %485
br i1 %486, label %487, label %496
487: ; preds = %483
%488 = load i8*, i8** %6
%489 = load i32, i32* %10
%490 = sub nsw i32 %489, 1
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds i8, i8* %488, i64 %491
%493 = load i8, i8* %492
%494 = call i64 @iswhite(i8 signext %493)
%495 = icmp ne i64 %494, 0
br label %496
496: ; preds = %487, %483
%497 = phi i1 [ false, %483 ], [ %495, %487 ]
br i1 %497, label %498, label %501
498: ; preds = %496
%499 = load i32, i32* %10
%500 = add nsw i32 %499, -1
store i32 %500, i32* %10
br label %483
501: ; preds = %496
br label %502
502: ; preds = %516, %501
%503 = load i32, i32* %8
%504 = load i32, i32* %11
%505 = icmp sgt i32 %503, %504
br i1 %505, label %506, label %514
506: ; preds = %502
%507 = load i8*, i8** %6
%508 = load i32, i32* %11
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds i8, i8* %507, i64 %509
%511 = load i8, i8* %510
%512 = call i64 @iswhite(i8 signext %511)
%513 = icmp ne i64 %512, 0
br label %514
514: ; preds = %506, %502
%515 = phi i1 [ false, %502 ], [ %513, %506 ]
br i1 %515, label %516, label %519
516: ; preds = %514
%517 = load i32, i32* %11
%518 = add nsw i32 %517, 1
store i32 %518, i32* %11
br label %502
519: ; preds = %514
%520 = load i32, i32* %10
%521 = load i32, i32* %7
%522 = sub nsw i32 %520, %521
store i32 %522, i32* %14
%523 = load i32, i32* %14
%524 = load i32, i32* %8
%525 = load i32, i32* %11
%526 = sub nsw i32 %524, %525
%527 = icmp sgt i32 %523, %526
br i1 %527, label %528, label %532
528: ; preds = %519
%529 = load i32, i32* %8
%530 = load i32, i32* %11
%531 = sub nsw i32 %529, %530
store i32 %531, i32* %14
br label %532
532: ; preds = %528, %519
%533 = load i8*, i8** %6
%534 = load i32, i32* %7
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds i8, i8* %533, i64 %535
%537 = load i8*, i8** %6
%538 = load i32, i32* %11
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds i8, i8* %537, i64 %539
%541 = load i32, i32* %14
%542 = call i32 @strncmp(i8* %536, i8* %540, i32 %541)
store i32 %542, i32* %12
%543 = load i32, i32* %12
%544 = icmp sgt i32 %543, 0
br i1 %544, label %558, label %545
545: ; preds = %532
%546 = load i32, i32* %12
%547 = icmp eq i32 %546, 0
br i1 %547, label %548, label %556
548: ; preds = %545
%549 = load i32, i32* %10
%550 = load i32, i32* %7
%551 = sub nsw i32 %549, %550
%552 = load i32, i32* %8
%553 = load i32, i32* %11
%554 = sub nsw i32 %552, %553
%555 = icmp sge i32 %551, %554
br label %556
556: ; preds = %548, %545
%557 = phi i1 [ false, %545 ], [ %555, %548 ]
br label %558
558: ; preds = %556, %532
%559 = phi i1 [ true, %532 ], [ %557, %556 ]
%560 = zext i1 %559 to i32
%561 = load i32*, i32** %9
store i32 %560, i32* %561
br label %568
562: ; preds = %476
%563 = load i32, i32* %12
%564 = load i32, i32* %13
%565 = icmp sge i32 %563, %564
%566 = zext i1 %565 to i32
%567 = load i32*, i32** %9
store i32 %566, i32* %567
br label %568
568: ; preds = %562, %558
store i32 1, i32* %5
br label %1161
569: ; preds = %464
%570 = load i8*, i8** %6
%571 = load i32, i32* %7
%572 = load i32, i32* %8
%573 = call i64 @splice_infix(i8* %570, i32 %571, i32 %572, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0), i32* %10, i32* %11)
%574 = icmp ne i64 %573, 0
br i1 %574, label %575, label %674
575: ; preds = %569
%576 = load i8*, i8** %6
%577 = load i32, i32* %7
%578 = load i32, i32* %10
%579 = call i32 @do_arithm_eval(i8* %576, i32 %577, i32 %578, i32* %12)
%580 = icmp ne i32 %579, 0
br i1 %580, label %581, label %587
581: ; preds = %575
%582 = load i8*, i8** %6
%583 = load i32, i32* %11
%584 = load i32, i32* %8
%585 = call i32 @do_arithm_eval(i8* %582, i32 %583, i32 %584, i32* %13)
%586 = icmp ne i32 %585, 0
br i1 %586, label %667, label %587
587: ; preds = %581, %575
br label %588
588: ; preds = %603, %587
%589 = load i32, i32* %7
%590 = load i32, i32* %10
%591 = icmp slt i32 %589, %590
br i1 %591, label %592, label %601
592: ; preds = %588
%593 = load i8*, i8** %6
%594 = load i32, i32* %10
%595 = sub nsw i32 %594, 1
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds i8, i8* %593, i64 %596
%598 = load i8, i8* %597
%599 = call i64 @iswhite(i8 signext %598)
%600 = icmp ne i64 %599, 0
br label %601
601: ; preds = %592, %588
%602 = phi i1 [ false, %588 ], [ %600, %592 ]
br i1 %602, label %603, label %606
603: ; preds = %601
%604 = load i32, i32* %10
%605 = add nsw i32 %604, -1
store i32 %605, i32* %10
br label %588
606: ; preds = %601
br label %607
607: ; preds = %621, %606
%608 = load i32, i32* %8
%609 = load i32, i32* %11
%610 = icmp sgt i32 %608, %609
br i1 %610, label %611, label %619
611: ; preds = %607
%612 = load i8*, i8** %6
%613 = load i32, i32* %11
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds i8, i8* %612, i64 %614
%616 = load i8, i8* %615
%617 = call i64 @iswhite(i8 signext %616)
%618 = icmp ne i64 %617, 0
br label %619
619: ; preds = %611, %607
%620 = phi i1 [ false, %607 ], [ %618, %611 ]
br i1 %620, label %621, label %624
621: ; preds = %619
%622 = load i32, i32* %11
%623 = add nsw i32 %622, 1
store i32 %623, i32* %11
br label %607
624: ; preds = %619
%625 = load i32, i32* %10
%626 = load i32, i32* %7
%627 = sub nsw i32 %625, %626
store i32 %627, i32* %14
%628 = load i32, i32* %14
%629 = load i32, i32* %8
%630 = load i32, i32* %11
%631 = sub nsw i32 %629, %630
%632 = icmp sgt i32 %628, %631
br i1 %632, label %633, label %637
633: ; preds = %624
%634 = load i32, i32* %8
%635 = load i32, i32* %11
%636 = sub nsw i32 %634, %635
store i32 %636, i32* %14
br label %637
637: ; preds = %633, %624
%638 = load i8*, i8** %6
%639 = load i32, i32* %7
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds i8, i8* %638, i64 %640
%642 = load i8*, i8** %6
%643 = load i32, i32* %11
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds i8, i8* %642, i64 %644
%646 = load i32, i32* %14
%647 = call i32 @strncmp(i8* %641, i8* %645, i32 %646)
store i32 %647, i32* %12
%648 = load i32, i32* %12
%649 = icmp sgt i32 %648, 0
br i1 %649, label %663, label %650
650: ; preds = %637
%651 = load i32, i32* %12
%652 = icmp eq i32 %651, 0
br i1 %652, label %653, label %661
653: ; preds = %650
%654 = load i32, i32* %10
%655 = load i32, i32* %7
%656 = sub nsw i32 %654, %655
%657 = load i32, i32* %8
%658 = load i32, i32* %11
%659 = sub nsw i32 %657, %658
%660 = icmp sgt i32 %656, %659
br label %661
661: ; preds = %653, %650
%662 = phi i1 [ false, %650 ], [ %660, %653 ]
br label %663
663: ; preds = %661, %637
%664 = phi i1 [ true, %637 ], [ %662, %661 ]
%665 = zext i1 %664 to i32
%666 = load i32*, i32** %9
store i32 %665, i32* %666
br label %673
667: ; preds = %581
%668 = load i32, i32* %12
%669 = load i32, i32* %13
%670 = icmp sgt i32 %668, %669
%671 = zext i1 %670 to i32
%672 = load i32*, i32** %9
store i32 %671, i32* %672
br label %673
673: ; preds = %667, %663
store i32 1, i32* %5
br label %1161
674: ; preds = %569
%675 = load i8*, i8** %6
%676 = load i32, i32* %7
%677 = load i32, i32* %8
%678 = call i64 @splice_infix(i8* %675, i32 %676, i32 %677, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0), i32* %10, i32* %11)
%679 = icmp ne i64 %678, 0
br i1 %679, label %680, label %779
680: ; preds = %674
%681 = load i8*, i8** %6
%682 = load i32, i32* %7
%683 = load i32, i32* %10
%684 = call i32 @do_arithm_eval(i8* %681, i32 %682, i32 %683, i32* %12)
%685 = icmp ne i32 %684, 0
br i1 %685, label %686, label %692
686: ; preds = %680
%687 = load i8*, i8** %6
%688 = load i32, i32* %11
%689 = load i32, i32* %8
%690 = call i32 @do_arithm_eval(i8* %687, i32 %688, i32 %689, i32* %13)
%691 = icmp ne i32 %690, 0
br i1 %691, label %772, label %692
692: ; preds = %686, %680
br label %693
693: ; preds = %708, %692
%694 = load i32, i32* %7
%695 = load i32, i32* %10
%696 = icmp slt i32 %694, %695
br i1 %696, label %697, label %706
697: ; preds = %693
%698 = load i8*, i8** %6
%699 = load i32, i32* %10
%700 = sub nsw i32 %699, 1
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds i8, i8* %698, i64 %701
%703 = load i8, i8* %702
%704 = call i64 @iswhite(i8 signext %703)
%705 = icmp ne i64 %704, 0
br label %706
706: ; preds = %697, %693
%707 = phi i1 [ false, %693 ], [ %705, %697 ]
br i1 %707, label %708, label %711
708: ; preds = %706
%709 = load i32, i32* %10
%710 = add nsw i32 %709, -1
store i32 %710, i32* %10
br label %693
711: ; preds = %706
br label %712
712: ; preds = %726, %711
%713 = load i32, i32* %8
%714 = load i32, i32* %11
%715 = icmp sgt i32 %713, %714
br i1 %715, label %716, label %724
716: ; preds = %712
%717 = load i8*, i8** %6
%718 = load i32, i32* %11
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds i8, i8* %717, i64 %719
%721 = load i8, i8* %720
%722 = call i64 @iswhite(i8 signext %721)
%723 = icmp ne i64 %722, 0
br label %724
724: ; preds = %716, %712
%725 = phi i1 [ false, %712 ], [ %723, %716 ]
br i1 %725, label %726, label %729
726: ; preds = %724
%727 = load i32, i32* %11
%728 = add nsw i32 %727, 1
store i32 %728, i32* %11
br label %712
729: ; preds = %724
%730 = load i32, i32* %10
%731 = load i32, i32* %7
%732 = sub nsw i32 %730, %731
store i32 %732, i32* %14
%733 = load i32, i32* %14
%734 = load i32, i32* %8
%735 = load i32, i32* %11
%736 = sub nsw i32 %734, %735
%737 = icmp sgt i32 %733, %736
br i1 %737, label %738, label %742
738: ; preds = %729
%739 = load i32, i32* %8
%740 = load i32, i32* %11
%741 = sub nsw i32 %739, %740
store i32 %741, i32* %14
br label %742
742: ; preds = %738, %729
%743 = load i8*, i8** %6
%744 = load i32, i32* %7
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds i8, i8* %743, i64 %745
%747 = load i8*, i8** %6
%748 = load i32, i32* %11
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds i8, i8* %747, i64 %749
%751 = load i32, i32* %14
%752 = call i32 @strncmp(i8* %746, i8* %750, i32 %751)
store i32 %752, i32* %12
%753 = load i32, i32* %12
%754 = icmp slt i32 %753, 0
br i1 %754, label %768, label %755
755: ; preds = %742
%756 = load i32, i32* %12
%757 = icmp eq i32 %756, 0
br i1 %757, label %758, label %766
758: ; preds = %755
%759 = load i32, i32* %10
%760 = load i32, i32* %7
%761 = sub nsw i32 %759, %760
%762 = load i32, i32* %8
%763 = load i32, i32* %11
%764 = sub nsw i32 %762, %763
%765 = icmp sle i32 %761, %764
br label %766
766: ; preds = %758, %755
%767 = phi i1 [ false, %755 ], [ %765, %758 ]
br label %768
768: ; preds = %766, %742
%769 = phi i1 [ true, %742 ], [ %767, %766 ]
%770 = zext i1 %769 to i32
%771 = load i32*, i32** %9
store i32 %770, i32* %771
br label %778
772: ; preds = %686
%773 = load i32, i32* %12
%774 = load i32, i32* %13
%775 = icmp sle i32 %773, %774
%776 = zext i1 %775 to i32
%777 = load i32*, i32** %9
store i32 %776, i32* %777
br label %778
778: ; preds = %772, %768
store i32 1, i32* %5
br label %1161
779: ; preds = %674
%780 = load i8*, i8** %6
%781 = load i32, i32* %7
%782 = load i32, i32* %8
%783 = call i64 @splice_infix(i8* %780, i32 %781, i32 %782, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i32* %10, i32* %11)
%784 = icmp ne i64 %783, 0
br i1 %784, label %785, label %884
785: ; preds = %779
%786 = load i8*, i8** %6
%787 = load i32, i32* %7
%788 = load i32, i32* %10
%789 = call i32 @do_arithm_eval(i8* %786, i32 %787, i32 %788, i32* %12)
%790 = icmp ne i32 %789, 0
br i1 %790, label %791, label %797
791: ; preds = %785
%792 = load i8*, i8** %6
%793 = load i32, i32* %11
%794 = load i32, i32* %8
%795 = call i32 @do_arithm_eval(i8* %792, i32 %793, i32 %794, i32* %13)
%796 = icmp ne i32 %795, 0
br i1 %796, label %877, label %797
797: ; preds = %791, %785
br label %798
798: ; preds = %813, %797
%799 = load i32, i32* %7
%800 = load i32, i32* %10
%801 = icmp slt i32 %799, %800
br i1 %801, label %802, label %811
802: ; preds = %798
%803 = load i8*, i8** %6
%804 = load i32, i32* %10
%805 = sub nsw i32 %804, 1
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds i8, i8* %803, i64 %806
%808 = load i8, i8* %807
%809 = call i64 @iswhite(i8 signext %808)
%810 = icmp ne i64 %809, 0
br label %811
811: ; preds = %802, %798
%812 = phi i1 [ false, %798 ], [ %810, %802 ]
br i1 %812, label %813, label %816
813: ; preds = %811
%814 = load i32, i32* %10
%815 = add nsw i32 %814, -1
store i32 %815, i32* %10
br label %798
816: ; preds = %811
br label %817
817: ; preds = %831, %816
%818 = load i32, i32* %8
%819 = load i32, i32* %11
%820 = icmp sgt i32 %818, %819
br i1 %820, label %821, label %829
821: ; preds = %817
%822 = load i8*, i8** %6
%823 = load i32, i32* %11
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds i8, i8* %822, i64 %824
%826 = load i8, i8* %825
%827 = call i64 @iswhite(i8 signext %826)
%828 = icmp ne i64 %827, 0
br label %829
829: ; preds = %821, %817
%830 = phi i1 [ false, %817 ], [ %828, %821 ]
br i1 %830, label %831, label %834
831: ; preds = %829
%832 = load i32, i32* %11
%833 = add nsw i32 %832, 1
store i32 %833, i32* %11
br label %817
834: ; preds = %829
%835 = load i32, i32* %10
%836 = load i32, i32* %7
%837 = sub nsw i32 %835, %836
store i32 %837, i32* %14
%838 = load i32, i32* %14
%839 = load i32, i32* %8
%840 = load i32, i32* %11
%841 = sub nsw i32 %839, %840
%842 = icmp sgt i32 %838, %841
br i1 %842, label %843, label %847
843: ; preds = %834
%844 = load i32, i32* %8
%845 = load i32, i32* %11
%846 = sub nsw i32 %844, %845
store i32 %846, i32* %14
br label %847
847: ; preds = %843, %834
%848 = load i8*, i8** %6
%849 = load i32, i32* %7
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds i8, i8* %848, i64 %850
%852 = load i8*, i8** %6
%853 = load i32, i32* %11
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds i8, i8* %852, i64 %854
%856 = load i32, i32* %14
%857 = call i32 @strncmp(i8* %851, i8* %855, i32 %856)
store i32 %857, i32* %12
%858 = load i32, i32* %12
%859 = icmp slt i32 %858, 0
br i1 %859, label %873, label %860
860: ; preds = %847
%861 = load i32, i32* %12
%862 = icmp eq i32 %861, 0
br i1 %862, label %863, label %871
863: ; preds = %860
%864 = load i32, i32* %10
%865 = load i32, i32* %7
%866 = sub nsw i32 %864, %865
%867 = load i32, i32* %8
%868 = load i32, i32* %11
%869 = sub nsw i32 %867, %868
%870 = icmp slt i32 %866, %869
br label %871
871: ; preds = %863, %860
%872 = phi i1 [ false, %860 ], [ %870, %863 ]
br label %873
873: ; preds = %871, %847
%874 = phi i1 [ true, %847 ], [ %872, %871 ]
%875 = zext i1 %874 to i32
%876 = load i32*, i32** %9
store i32 %875, i32* %876
br label %883
877: ; preds = %791
%878 = load i32, i32* %12
%879 = load i32, i32* %13
%880 = icmp slt i32 %878, %879
%881 = zext i1 %880 to i32
%882 = load i32*, i32** %9
store i32 %881, i32* %882
br label %883
883: ; preds = %877, %873
store i32 1, i32* %5
br label %1161
884: ; preds = %779
%885 = load i8*, i8** %6
%886 = load i32, i32* %7
%887 = load i32, i32* %8
%888 = call i64 @splice_infix(i8* %885, i32 %886, i32 %887, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0), i32* %10, i32* %11)
%889 = icmp ne i64 %888, 0
br i1 %889, label %890, label %908
890: ; preds = %884
%891 = load i8*, i8** %6
%892 = load i32, i32* %7
%893 = load i32, i32* %10
%894 = call i32 @do_arithm_eval(i8* %891, i32 %892, i32 %893, i32* %12)
%895 = icmp ne i32 %894, 0
br i1 %895, label %896, label %902
896: ; preds = %890
%897 = load i8*, i8** %6
%898 = load i32, i32* %11
%899 = load i32, i32* %8
%900 = call i32 @do_arithm_eval(i8* %897, i32 %898, i32 %899, i32* %13)
%901 = icmp ne i32 %900, 0
br i1 %901, label %903, label %902
902: ; preds = %896, %890
store i32 0, i32* %5
br label %1161
903: ; preds = %896
%904 = load i32, i32* %12
%905 = load i32, i32* %13
%906 = add nsw i32 %904, %905
%907 = load i32*, i32** %9
store i32 %906, i32* %907
store i32 1, i32* %5
br label %1161
908: ; preds = %884
%909 = load i8*, i8** %6
%910 = load i32, i32* %7
%911 = load i32, i32* %8
%912 = call i64 @splice_infix(i8* %909, i32 %910, i32 %911, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), i32* %10, i32* %11)
%913 = icmp ne i64 %912, 0
br i1 %913, label %914, label %937
914: ; preds = %908
%915 = load i32, i32* %10
%916 = load i32, i32* %7
%917 = icmp ne i32 %915, %916
br i1 %917, label %918, label %936
918: ; preds = %914
%919 = load i8*, i8** %6
%920 = load i32, i32* %7
%921 = load i32, i32* %10
%922 = call i32 @do_arithm_eval(i8* %919, i32 %920, i32 %921, i32* %12)
%923 = icmp ne i32 %922, 0
br i1 %923, label %924, label %930
924: ; preds = %918
%925 = load i8*, i8** %6
%926 = load i32, i32* %11
%927 = load i32, i32* %8
%928 = call i32 @do_arithm_eval(i8* %925, i32 %926, i32 %927, i32* %13)
%929 = icmp ne i32 %928, 0
br i1 %929, label %931, label %930
930: ; preds = %924, %918
store i32 0, i32* %5
br label %1161
931: ; preds = %924
%932 = load i32, i32* %12
%933 = load i32, i32* %13
%934 = sub nsw i32 %932, %933
%935 = load i32*, i32** %9
store i32 %934, i32* %935
store i32 1, i32* %5
br label %1161
936: ; preds = %914
br label %937
937: ; preds = %936, %908
%938 = load i8*, i8** %6
%939 = load i32, i32* %7
%940 = load i32, i32* %8
%941 = call i64 @splice_infix(i8* %938, i32 %939, i32 %940, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0), i32* %10, i32* %11)
%942 = icmp ne i64 %941, 0
br i1 %942, label %943, label %961
943: ; preds = %937
%944 = load i8*, i8** %6
%945 = load i32, i32* %7
%946 = load i32, i32* %10
%947 = call i32 @do_arithm_eval(i8* %944, i32 %945, i32 %946, i32* %12)
%948 = icmp ne i32 %947, 0
br i1 %948, label %949, label %955
949: ; preds = %943
%950 = load i8*, i8** %6
%951 = load i32, i32* %11
%952 = load i32, i32* %8
%953 = call i32 @do_arithm_eval(i8* %950, i32 %951, i32 %952, i32* %13)
%954 = icmp ne i32 %953, 0
br i1 %954, label %956, label %955
955: ; preds = %949, %943
store i32 0, i32* %5
br label %1161
956: ; preds = %949
%957 = load i32, i32* %12
%958 = load i32, i32* %13
%959 = mul nsw i32 %957, %958
%960 = load i32*, i32** %9
store i32 %959, i32* %960
store i32 1, i32* %5
br label %1161
961: ; preds = %937
%962 = load i8*, i8** %6
%963 = load i32, i32* %7
%964 = load i32, i32* %8
%965 = call i64 @splice_infix(i8* %962, i32 %963, i32 %964, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i32* %10, i32* %11)
%966 = icmp ne i64 %965, 0
br i1 %966, label %967, label %990
967: ; preds = %961
%968 = load i8*, i8** %6
%969 = load i32, i32* %7
%970 = load i32, i32* %10
%971 = call i32 @do_arithm_eval(i8* %968, i32 %969, i32 %970, i32* %12)
%972 = icmp ne i32 %971, 0
br i1 %972, label %973, label %979
973: ; preds = %967
%974 = load i8*, i8** %6
%975 = load i32, i32* %11
%976 = load i32, i32* %8
%977 = call i32 @do_arithm_eval(i8* %974, i32 %975, i32 %976, i32* %13)
%978 = icmp ne i32 %977, 0
br i1 %978, label %980, label %979
979: ; preds = %973, %967
store i32 0, i32* %5
br label %1161
980: ; preds = %973
%981 = load i32, i32* %13
%982 = icmp eq i32 %981, 0
br i1 %982, label %983, label %985
983: ; preds = %980
%984 = call i32 @bug(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.17, i64 0, i64 0))
br label %985
985: ; preds = %983, %980
%986 = load i32, i32* %12
%987 = load i32, i32* %13
%988 = sdiv i32 %986, %987
%989 = load i32*, i32** %9
store i32 %988, i32* %989
store i32 1, i32* %5
br label %1161
990: ; preds = %961
%991 = load i8*, i8** %6
%992 = load i32, i32* %7
%993 = load i32, i32* %8
%994 = call i64 @splice_infix(i8* %991, i32 %992, i32 %993, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0), i32* %10, i32* %11)
%995 = icmp ne i64 %994, 0
br i1 %995, label %996, label %1019
996: ; preds = %990
%997 = load i8*, i8** %6
%998 = load i32, i32* %7
%999 = load i32, i32* %10
%1000 = call i32 @do_arithm_eval(i8* %997, i32 %998, i32 %999, i32* %12)
%1001 = icmp ne i32 %1000, 0
br i1 %1001, label %1002, label %1008
1002: ; preds = %996
%1003 = load i8*, i8** %6
%1004 = load i32, i32* %11
%1005 = load i32, i32* %8
%1006 = call i32 @do_arithm_eval(i8* %1003, i32 %1004, i32 %1005, i32* %13)
%1007 = icmp ne i32 %1006, 0
br i1 %1007, label %1009, label %1008
1008: ; preds = %1002, %996
store i32 0, i32* %5
br label %1161
1009: ; preds = %1002
%1010 = load i32, i32* %13
%1011 = icmp eq i32 %1010, 0
br i1 %1011, label %1012, label %1014
1012: ; preds = %1009
%1013 = call i32 @bug(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.17, i64 0, i64 0))
br label %1014
1014: ; preds = %1012, %1009
%1015 = load i32, i32* %12
%1016 = load i32, i32* %13
%1017 = srem i32 %1015, %1016
%1018 = load i32*, i32** %9
store i32 %1017, i32* %1018
store i32 1, i32* %5
br label %1161
1019: ; preds = %990
%1020 = load i8*, i8** %6
%1021 = load i32, i32* %7
%1022 = sext i32 %1021 to i64
%1023 = getelementptr inbounds i8, i8* %1020, i64 %1022
%1024 = load i8, i8* %1023
%1025 = sext i8 %1024 to i32
%1026 = icmp eq i32 %1025, 126
br i1 %1026, label %1027, label %1039
1027: ; preds = %1019
%1028 = load i8*, i8** %6
%1029 = load i32, i32* %7
%1030 = add nsw i32 %1029, 1
%1031 = load i32, i32* %8
%1032 = call i32 @do_arithm_eval(i8* %1028, i32 %1030, i32 %1031, i32* %12)
%1033 = icmp ne i32 %1032, 0
br i1 %1033, label %1035, label %1034
1034: ; preds = %1027
store i32 0, i32* %5
br label %1161
1035: ; preds = %1027
%1036 = load i32, i32* %12
%1037 = xor i32 %1036, -1
%1038 = load i32*, i32** %9
store i32 %1037, i32* %1038
store i32 1, i32* %5
br label %1161
1039: ; preds = %1019
%1040 = load i8*, i8** %6
%1041 = load i32, i32* %7
%1042 = sext i32 %1041 to i64
%1043 = getelementptr inbounds i8, i8* %1040, i64 %1042
%1044 = load i8, i8* %1043
%1045 = sext i8 %1044 to i32
%1046 = icmp eq i32 %1045, 33
br i1 %1046, label %1047, label %1061
1047: ; preds = %1039
%1048 = load i8*, i8** %6
%1049 = load i32, i32* %7
%1050 = add nsw i32 %1049, 1
%1051 = load i32, i32* %8
%1052 = call i32 @do_arithm_eval(i8* %1048, i32 %1050, i32 %1051, i32* %12)
%1053 = icmp ne i32 %1052, 0
br i1 %1053, label %1055, label %1054
1054: ; preds = %1047
store i32 0, i32* %5
br label %1161
1055: ; preds = %1047
%1056 = load i32, i32* %12
%1057 = icmp ne i32 %1056, 0
%1058 = xor i1 %1057, true
%1059 = zext i1 %1058 to i32
%1060 = load i32*, i32** %9
store i32 %1059, i32* %1060
store i32 1, i32* %5
br label %1161
1061: ; preds = %1039
%1062 = load i8*, i8** %6
%1063 = load i32, i32* %7
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds i8, i8* %1062, i64 %1064
%1066 = load i8, i8* %1065
%1067 = sext i8 %1066 to i32
%1068 = icmp eq i32 %1067, 45
br i1 %1068, label %1069, label %1081
1069: ; preds = %1061
%1070 = load i8*, i8** %6
%1071 = load i32, i32* %7
%1072 = add nsw i32 %1071, 1
%1073 = load i32, i32* %8
%1074 = call i32 @do_arithm_eval(i8* %1070, i32 %1072, i32 %1073, i32* %12)
%1075 = icmp ne i32 %1074, 0
br i1 %1075, label %1077, label %1076
1076: ; preds = %1069
store i32 0, i32* %5
br label %1161
1077: ; preds = %1069
%1078 = load i32, i32* %12
%1079 = sub nsw i32 0, %1078
%1080 = load i32*, i32** %9
store i32 %1079, i32* %1080
store i32 1, i32* %5
br label %1161
1081: ; preds = %1061
%1082 = load i8*, i8** %6
%1083 = load i32, i32* %7
%1084 = sext i32 %1083 to i64
%1085 = getelementptr inbounds i8, i8* %1082, i64 %1084
%1086 = call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i64 0, i64 0))
%1087 = call i32 @strncmp(i8* %1085, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i64 0, i64 0), i32 %1086)
%1088 = icmp eq i32 %1087, 0
br i1 %1088, label %1089, label %1106
1089: ; preds = %1081
%1090 = load i8*, i8** %6
%1091 = load i32, i32* %8
%1092 = sub nsw i32 %1091, 1
%1093 = sext i32 %1092 to i64
%1094 = getelementptr inbounds i8, i8* %1090, i64 %1093
%1095 = load i8, i8* %1094
%1096 = sext i8 %1095 to i32
%1097 = icmp ne i32 %1096, 41
br i1 %1097, label %1098, label %1099
1098: ; preds = %1089
store i32 0, i32* %5
br label %1161
1099: ; preds = %1089
%1100 = load i32, i32* %8
%1101 = load i32, i32* %7
%1102 = sub nsw i32 %1100, %1101
%1103 = call i32 @strlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.20, i64 0, i64 0))
%1104 = sub nsw i32 %1102, %1103
%1105 = load i32*, i32** %9
store i32 %1104, i32* %1105
store i32 1, i32* %5
br label %1161
1106: ; preds = %1081
%1107 = load i8*, i8** %6
%1108 = load i32, i32* %7
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds i8, i8* %1107, i64 %1109
%1111 = load i8, i8* %1110
%1112 = sext i8 %1111 to i32
%1113 = icmp eq i32 %1112, 40
br i1 %1113, label %1114, label %1132
1114: ; preds = %1106
%1115 = load i8*, i8** %6
%1116 = load i32, i32* %8
%1117 = sub nsw i32 %1116, 1
%1118 = sext i32 %1117 to i64
%1119 = getelementptr inbounds i8, i8* %1115, i64 %1118
%1120 = load i8, i8* %1119
%1121 = sext i8 %1120 to i32
%1122 = icmp ne i32 %1121, 41
br i1 %1122, label %1123, label %1124
1123: ; preds = %1114
store i32 0, i32* %5
br label %1161
1124: ; preds = %1114
%1125 = load i8*, i8** %6
%1126 = load i32, i32* %7
%1127 = add nsw i32 %1126, 1
%1128 = load i32, i32* %8
%1129 = sub nsw i32 %1128, 1
%1130 = load i32*, i32** %9
%1131 = call i32 @do_arithm_eval(i8* %1125, i32 %1127, i32 %1129, i32* %1130)
store i32 %1131, i32* %5
br label %1161
1132: ; preds = %1106
%1133 = load i8*, i8** %6
%1134 = load i32, i32* %8
%1135 = sext i32 %1134 to i64
%1136 = getelementptr inbounds i8, i8* %1133, i64 %1135
%1137 = load i8, i8* %1136
store i8 %1137, i8* %15
%1138 = load i8*, i8** %6
%1139 = load i32, i32* %8
%1140 = sext i32 %1139 to i64
%1141 = getelementptr inbounds i8, i8* %1138, i64 %1140
store i8 0, i8* %1141
%1142 = load i8*, i8** %6
%1143 = load i32, i32* %7
%1144 = sext i32 %1143 to i64
%1145 = getelementptr inbounds i8, i8* %1142, i64 %1144
%1146 = call i64 @strtol(i8* %1145, i8** %16, i32 0)
%1147 = trunc i64 %1146 to i32
%1148 = load i32*, i32** %9
store i32 %1147, i32* %1148
%1149 = load i8, i8* %15
%1150 = load i8*, i8** %6
%1151 = load i32, i32* %8
%1152 = sext i32 %1151 to i64
%1153 = getelementptr inbounds i8, i8* %1150, i64 %1152
store i8 %1149, i8* %1153
%1154 = load i8*, i8** %16
%1155 = load i8*, i8** %6
%1156 = load i32, i32* %8
%1157 = sext i32 %1156 to i64
%1158 = getelementptr inbounds i8, i8* %1155, i64 %1157
%1159 = icmp eq i8* %1154, %1158
%1160 = zext i1 %1159 to i32
store i32 %1160, i32* %5
br label %1161
1161: ; preds = %1132, %1124, %1123, %1099, %1098, %1077, %1076, %1055, %1054, %1035, %1034, %1014, %1008, %985, %979, %956, %955, %931, %930, %903, %902, %883, %778, %673, %568, %463, %367, %278, %185, %184, %161, %160, %137, %136, %114, %107, %85, %78, %59
%1162 = load i32, i32* %5
ret i32 %1162
}

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 @do_arithm_eval(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 %732, label %51
51: ; preds = %48
%52 = call i64 @splice_infix(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 @do_arithm_eval(i8* %0, i32 %34, i32 %55, i32* %7)
%57 = icmp eq i32 %56, 0
br i1 %57, label %732, label %58
58: ; preds = %54
%59 = load i32, i32* %6
%60 = call i32 @do_arithm_eval(i8* %0, i32 %59, i32 %49, i32* %8)
%61 = icmp eq i32 %60, 0
br i1 %61, label %732, 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 %732
69: ; preds = %51
%70 = call i64 @splice_infix(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 @do_arithm_eval(i8* %0, i32 %34, i32 %73, i32* %7)
%75 = icmp eq i32 %74, 0
br i1 %75, label %732, label %76
76: ; preds = %72
%77 = load i32, i32* %6
%78 = call i32 @do_arithm_eval(i8* %0, i32 %77, i32 %49, i32* %8)
%79 = icmp eq i32 %78, 0
br i1 %79, label %732, 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 %732
87: ; preds = %69
%88 = call i64 @splice_infix(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 @do_arithm_eval(i8* %0, i32 %34, i32 %91, i32* %7)
%93 = icmp eq i32 %92, 0
br i1 %93, label %732, label %94
94: ; preds = %90
%95 = load i32, i32* %6
%96 = call i32 @do_arithm_eval(i8* %0, i32 %95, i32 %49, i32* %8)
%97 = icmp eq i32 %96, 0
br i1 %97, label %732, 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 %732
102: ; preds = %87
%103 = call i64 @splice_infix(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 @do_arithm_eval(i8* %0, i32 %34, i32 %106, i32* %7)
%108 = icmp eq i32 %107, 0
br i1 %108, label %732, label %109
109: ; preds = %105
%110 = load i32, i32* %6
%111 = call i32 @do_arithm_eval(i8* %0, i32 %110, i32 %49, i32* %8)
%112 = icmp eq i32 %111, 0
br i1 %112, label %732, 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 %732
117: ; preds = %102
%118 = call i64 @splice_infix(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 @do_arithm_eval(i8* %0, i32 %34, i32 %121, i32* %7)
%123 = icmp eq i32 %122, 0
br i1 %123, label %732, label %124
124: ; preds = %120
%125 = load i32, i32* %6
%126 = call i32 @do_arithm_eval(i8* %0, i32 %125, i32 %49, i32* %8)
%127 = icmp eq i32 %126, 0
br i1 %127, label %732, 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 %732
132: ; preds = %117
%133 = call i64 @splice_infix(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 @do_arithm_eval(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 @do_arithm_eval(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 %732
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 %732
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 %732
191: ; preds = %132
%192 = call i64 @splice_infix(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 @do_arithm_eval(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 @do_arithm_eval(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 %732
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 %732
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 %732
250: ; preds = %191
%251 = call i64 @splice_infix(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 %315, label %253
253: ; preds = %250
%254 = call i32 @bug(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.8, i64 0, i64 0))
%255 = load i32, i32* %5
%256 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %255, i32* %7)
%257 = icmp eq i32 %256, 0
br i1 %257, label %262, label %258
258: ; preds = %253
%259 = load i32, i32* %6
%260 = call i32 @do_arithm_eval(i8* %0, i32 %259, i32 %49, i32* %8)
%261 = icmp eq i32 %260, 0
br i1 %261, label %262, label %310
262: ; preds = %258, %253
%263 = load i32, i32* %5
%264 = icmp slt i32 %34, %263
br i1 %264, label %265, label %277
265: ; preds = %262, %273
%266 = phi i32 [ %275, %273 ], [ %263, %262 ]
%267 = add nsw i32 %266, -1
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i8, i8* %0, i64 %268
%270 = load i8, i8* %269
%271 = call i64 @iswhite(i8 signext %270)
%272 = icmp eq i64 %271, 0
br i1 %272, label %277, label %273
273: ; preds = %265
%274 = load i32, i32* %5
%275 = add nsw i32 %274, -1
store i32 %275, i32* %5
%276 = icmp slt i32 %34, %275
br i1 %276, label %265, label %277
277: ; preds = %265, %273, %262
%278 = load i32, i32* %6
%279 = icmp sgt i32 %49, %278
br i1 %279, label %280, label %291
280: ; preds = %277, %288
%281 = phi i32 [ %289, %288 ], [ %278, %277 ]
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i8, i8* %0, i64 %282
%284 = load i8, i8* %283
%285 = call i64 @iswhite(i8 signext %284)
%286 = icmp eq i64 %285, 0
%287 = load i32, i32* %6
br i1 %286, label %291, label %288
288: ; preds = %280
%289 = add nsw i32 %287, 1
store i32 %289, i32* %6
%290 = icmp sgt i32 %49, %289
br i1 %290, label %280, label %291
291: ; preds = %288, %280, %277
%292 = phi i32 [ %278, %277 ], [ %287, %280 ], [ %289, %288 ]
%293 = getelementptr inbounds i8, i8* %0, i64 %35
%294 = call i8* @strdup(i8* %293)
%295 = load i32, i32* %5
%296 = sub nsw i32 %295, %34
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i8, i8* %294, i64 %297
store i8 0, i8* %298
%299 = sext i32 %292 to i64
%300 = getelementptr inbounds i8, i8* %0, i64 %299
%301 = call i8* @strdup(i8* %300)
%302 = sub nsw i32 %49, %292
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i8, i8* %301, i64 %303
store i8 0, i8* %304
%305 = call i64 @fnmatch(i8* %301, i8* %294, i32 0)
%306 = icmp eq i64 %305, 0
%307 = zext i1 %306 to i32
store i32 %307, i32* %3
%308 = call i32 @free(i8* %294)
%309 = call i32 @free(i8* %301)
br label %732
310: ; preds = %258
%311 = load i32, i32* %7
%312 = load i32, i32* %8
%313 = icmp eq i32 %311, %312
%314 = zext i1 %313 to i32
store i32 %314, i32* %3
br label %732
315: ; preds = %250
%316 = call i64 @splice_infix(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)
%317 = icmp eq i64 %316, 0
br i1 %317, label %382, label %318
318: ; preds = %315
%319 = load i32, i32* %5
%320 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %319, i32* %7)
%321 = icmp eq i32 %320, 0
br i1 %321, label %326, label %322
322: ; preds = %318
%323 = load i32, i32* %6
%324 = call i32 @do_arithm_eval(i8* %0, i32 %323, i32 %49, i32* %8)
%325 = icmp eq i32 %324, 0
br i1 %325, label %326, label %375
326: ; preds = %322, %318
%327 = load i32, i32* %5
%328 = icmp slt i32 %34, %327
br i1 %328, label %329, label %341
329: ; preds = %326, %337
%330 = phi i32 [ %339, %337 ], [ %327, %326 ]
%331 = add nsw i32 %330, -1
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds i8, i8* %0, i64 %332
%334 = load i8, i8* %333
%335 = call i64 @iswhite(i8 signext %334)
%336 = icmp eq i64 %335, 0
br i1 %336, label %341, label %337
337: ; preds = %329
%338 = load i32, i32* %5
%339 = add nsw i32 %338, -1
store i32 %339, i32* %5
%340 = icmp slt i32 %34, %339
br i1 %340, label %329, label %341
341: ; preds = %329, %337, %326
%342 = load i32, i32* %6
%343 = icmp sgt i32 %49, %342
br i1 %343, label %344, label %355
344: ; preds = %341, %352
%345 = phi i32 [ %353, %352 ], [ %342, %341 ]
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i8, i8* %0, i64 %346
%348 = load i8, i8* %347
%349 = call i64 @iswhite(i8 signext %348)
%350 = icmp eq i64 %349, 0
%351 = load i32, i32* %6
br i1 %350, label %355, label %352
352: ; preds = %344
%353 = add nsw i32 %351, 1
store i32 %353, i32* %6
%354 = icmp sgt i32 %49, %353
br i1 %354, label %344, label %355
355: ; preds = %352, %344, %341
%356 = phi i32 [ %342, %341 ], [ %351, %344 ], [ %353, %352 ]
%357 = load i32, i32* %5
%358 = sub nsw i32 %357, %34
%359 = sub nsw i32 %49, %356
%360 = icmp sgt i32 %358, %359
%361 = select i1 %360, i32 %359, i32 %358
%362 = getelementptr inbounds i8, i8* %0, i64 %35
%363 = sext i32 %356 to i64
%364 = getelementptr inbounds i8, i8* %0, i64 %363
%365 = call i32 @strncmp(i8* %362, i8* %364, i32 %361)
store i32 %365, i32* %7
%366 = icmp sgt i32 %365, 0
br i1 %366, label %379, label %367
367: ; preds = %355
%368 = icmp eq i32 %365, 0
br i1 %368, label %369, label %379
369: ; preds = %367
%370 = load i32, i32* %5
%371 = sub nsw i32 %370, %34
%372 = load i32, i32* %6
%373 = sub nsw i32 %49, %372
%374 = icmp sge i32 %371, %373
br label %379
375: ; preds = %322
%376 = load i32, i32* %7
%377 = load i32, i32* %8
%378 = icmp sge i32 %376, %377
br label %379
379: ; preds = %355, %369, %367, %375
%380 = phi i1 [ %378, %375 ], [ true, %355 ], [ false, %367 ], [ %374, %369 ]
%381 = zext i1 %380 to i32
store i32 %381, i32* %3
br label %732
382: ; preds = %315
%383 = call i64 @splice_infix(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)
%384 = icmp eq i64 %383, 0
br i1 %384, label %449, label %385
385: ; preds = %382
%386 = load i32, i32* %5
%387 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %386, i32* %7)
%388 = icmp eq i32 %387, 0
br i1 %388, label %393, label %389
389: ; preds = %385
%390 = load i32, i32* %6
%391 = call i32 @do_arithm_eval(i8* %0, i32 %390, i32 %49, i32* %8)
%392 = icmp eq i32 %391, 0
br i1 %392, label %393, label %442
393: ; preds = %389, %385
%394 = load i32, i32* %5
%395 = icmp slt i32 %34, %394
br i1 %395, label %396, label %408
396: ; preds = %393, %404
%397 = phi i32 [ %406, %404 ], [ %394, %393 ]
%398 = add nsw i32 %397, -1
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds i8, i8* %0, i64 %399
%401 = load i8, i8* %400
%402 = call i64 @iswhite(i8 signext %401)
%403 = icmp eq i64 %402, 0
br i1 %403, label %408, label %404
404: ; preds = %396
%405 = load i32, i32* %5
%406 = add nsw i32 %405, -1
store i32 %406, i32* %5
%407 = icmp slt i32 %34, %406
br i1 %407, label %396, label %408
408: ; preds = %396, %404, %393
%409 = load i32, i32* %6
%410 = icmp sgt i32 %49, %409
br i1 %410, label %411, label %422
411: ; preds = %408, %419
%412 = phi i32 [ %420, %419 ], [ %409, %408 ]
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i8, i8* %0, i64 %413
%415 = load i8, i8* %414
%416 = call i64 @iswhite(i8 signext %415)
%417 = icmp eq i64 %416, 0
%418 = load i32, i32* %6
br i1 %417, label %422, label %419
419: ; preds = %411
%420 = add nsw i32 %418, 1
store i32 %420, i32* %6
%421 = icmp sgt i32 %49, %420
br i1 %421, label %411, label %422
422: ; preds = %419, %411, %408
%423 = phi i32 [ %409, %408 ], [ %418, %411 ], [ %420, %419 ]
%424 = load i32, i32* %5
%425 = sub nsw i32 %424, %34
%426 = sub nsw i32 %49, %423
%427 = icmp sgt i32 %425, %426
%428 = select i1 %427, i32 %426, i32 %425
%429 = getelementptr inbounds i8, i8* %0, i64 %35
%430 = sext i32 %423 to i64
%431 = getelementptr inbounds i8, i8* %0, i64 %430
%432 = call i32 @strncmp(i8* %429, i8* %431, i32 %428)
store i32 %432, i32* %7
%433 = icmp sgt i32 %432, 0
br i1 %433, label %446, label %434
434: ; preds = %422
%435 = icmp eq i32 %432, 0
br i1 %435, label %436, label %446
436: ; preds = %434
%437 = load i32, i32* %5
%438 = sub nsw i32 %437, %34
%439 = load i32, i32* %6
%440 = sub nsw i32 %49, %439
%441 = icmp sgt i32 %438, %440
br label %446
442: ; preds = %389
%443 = load i32, i32* %7
%444 = load i32, i32* %8
%445 = icmp sgt i32 %443, %444
br label %446
446: ; preds = %422, %436, %434, %442
%447 = phi i1 [ %445, %442 ], [ true, %422 ], [ false, %434 ], [ %441, %436 ]
%448 = zext i1 %447 to i32
store i32 %448, i32* %3
br label %732
449: ; preds = %382
%450 = call i64 @splice_infix(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)
%451 = icmp eq i64 %450, 0
br i1 %451, label %516, label %452
452: ; preds = %449
%453 = load i32, i32* %5
%454 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %453, i32* %7)
%455 = icmp eq i32 %454, 0
br i1 %455, label %460, label %456
456: ; preds = %452
%457 = load i32, i32* %6
%458 = call i32 @do_arithm_eval(i8* %0, i32 %457, i32 %49, i32* %8)
%459 = icmp eq i32 %458, 0
br i1 %459, label %460, label %509
460: ; preds = %456, %452
%461 = load i32, i32* %5
%462 = icmp slt i32 %34, %461
br i1 %462, label %463, label %475
463: ; preds = %460, %471
%464 = phi i32 [ %473, %471 ], [ %461, %460 ]
%465 = add nsw i32 %464, -1
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds i8, i8* %0, i64 %466
%468 = load i8, i8* %467
%469 = call i64 @iswhite(i8 signext %468)
%470 = icmp eq i64 %469, 0
br i1 %470, label %475, label %471
471: ; preds = %463
%472 = load i32, i32* %5
%473 = add nsw i32 %472, -1
store i32 %473, i32* %5
%474 = icmp slt i32 %34, %473
br i1 %474, label %463, label %475
475: ; preds = %463, %471, %460
%476 = load i32, i32* %6
%477 = icmp sgt i32 %49, %476
br i1 %477, label %478, label %489
478: ; preds = %475, %486
%479 = phi i32 [ %487, %486 ], [ %476, %475 ]
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds i8, i8* %0, i64 %480
%482 = load i8, i8* %481
%483 = call i64 @iswhite(i8 signext %482)
%484 = icmp eq i64 %483, 0
%485 = load i32, i32* %6
br i1 %484, label %489, label %486
486: ; preds = %478
%487 = add nsw i32 %485, 1
store i32 %487, i32* %6
%488 = icmp sgt i32 %49, %487
br i1 %488, label %478, label %489
489: ; preds = %486, %478, %475
%490 = phi i32 [ %476, %475 ], [ %485, %478 ], [ %487, %486 ]
%491 = load i32, i32* %5
%492 = sub nsw i32 %491, %34
%493 = sub nsw i32 %49, %490
%494 = icmp sgt i32 %492, %493
%495 = select i1 %494, i32 %493, i32 %492
%496 = getelementptr inbounds i8, i8* %0, i64 %35
%497 = sext i32 %490 to i64
%498 = getelementptr inbounds i8, i8* %0, i64 %497
%499 = call i32 @strncmp(i8* %496, i8* %498, i32 %495)
store i32 %499, i32* %7
%500 = icmp slt i32 %499, 0
br i1 %500, label %513, label %501
501: ; preds = %489
%502 = icmp eq i32 %499, 0
br i1 %502, label %503, label %513
503: ; preds = %501
%504 = load i32, i32* %5
%505 = sub nsw i32 %504, %34
%506 = load i32, i32* %6
%507 = sub nsw i32 %49, %506
%508 = icmp sle i32 %505, %507
br label %513
509: ; preds = %456
%510 = load i32, i32* %7
%511 = load i32, i32* %8
%512 = icmp sle i32 %510, %511
br label %513
513: ; preds = %489, %503, %501, %509
%514 = phi i1 [ %512, %509 ], [ true, %489 ], [ false, %501 ], [ %508, %503 ]
%515 = zext i1 %514 to i32
store i32 %515, i32* %3
br label %732
516: ; preds = %449
%517 = call i64 @splice_infix(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)
%518 = icmp eq i64 %517, 0
br i1 %518, label %583, label %519
519: ; preds = %516
%520 = load i32, i32* %5
%521 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %520, i32* %7)
%522 = icmp eq i32 %521, 0
br i1 %522, label %527, label %523
523: ; preds = %519
%524 = load i32, i32* %6
%525 = call i32 @do_arithm_eval(i8* %0, i32 %524, i32 %49, i32* %8)
%526 = icmp eq i32 %525, 0
br i1 %526, label %527, label %576
527: ; preds = %523, %519
%528 = load i32, i32* %5
%529 = icmp slt i32 %34, %528
br i1 %529, label %530, label %542
530: ; preds = %527, %538
%531 = phi i32 [ %540, %538 ], [ %528, %527 ]
%532 = add nsw i32 %531, -1
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i8, i8* %0, i64 %533
%535 = load i8, i8* %534
%536 = call i64 @iswhite(i8 signext %535)
%537 = icmp eq i64 %536, 0
br i1 %537, label %542, label %538
538: ; preds = %530
%539 = load i32, i32* %5
%540 = add nsw i32 %539, -1
store i32 %540, i32* %5
%541 = icmp slt i32 %34, %540
br i1 %541, label %530, label %542
542: ; preds = %530, %538, %527
%543 = load i32, i32* %6
%544 = icmp sgt i32 %49, %543
br i1 %544, label %545, label %556
545: ; preds = %542, %553
%546 = phi i32 [ %554, %553 ], [ %543, %542 ]
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds i8, i8* %0, i64 %547
%549 = load i8, i8* %548
%550 = call i64 @iswhite(i8 signext %549)
%551 = icmp eq i64 %550, 0
%552 = load i32, i32* %6
br i1 %551, label %556, label %553
553: ; preds = %545
%554 = add nsw i32 %552, 1
store i32 %554, i32* %6
%555 = icmp sgt i32 %49, %554
br i1 %555, label %545, label %556
556: ; preds = %553, %545, %542
%557 = phi i32 [ %543, %542 ], [ %552, %545 ], [ %554, %553 ]
%558 = load i32, i32* %5
%559 = sub nsw i32 %558, %34
%560 = sub nsw i32 %49, %557
%561 = icmp sgt i32 %559, %560
%562 = select i1 %561, i32 %560, i32 %559
%563 = getelementptr inbounds i8, i8* %0, i64 %35
%564 = sext i32 %557 to i64
%565 = getelementptr inbounds i8, i8* %0, i64 %564
%566 = call i32 @strncmp(i8* %563, i8* %565, i32 %562)
store i32 %566, i32* %7
%567 = icmp slt i32 %566, 0
br i1 %567, label %580, label %568
568: ; preds = %556
%569 = icmp eq i32 %566, 0
br i1 %569, label %570, label %580
570: ; preds = %568
%571 = load i32, i32* %5
%572 = sub nsw i32 %571, %34
%573 = load i32, i32* %6
%574 = sub nsw i32 %49, %573
%575 = icmp slt i32 %572, %574
br label %580
576: ; preds = %523
%577 = load i32, i32* %7
%578 = load i32, i32* %8
%579 = icmp slt i32 %577, %578
br label %580
580: ; preds = %556, %570, %568, %576
%581 = phi i1 [ %579, %576 ], [ true, %556 ], [ false, %568 ], [ %575, %570 ]
%582 = zext i1 %581 to i32
store i32 %582, i32* %3
br label %732
583: ; preds = %516
%584 = call i64 @splice_infix(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)
%585 = icmp eq i64 %584, 0
br i1 %585, label %598, label %586
586: ; preds = %583
%587 = load i32, i32* %5
%588 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %587, i32* %7)
%589 = icmp eq i32 %588, 0
br i1 %589, label %732, label %590
590: ; preds = %586
%591 = load i32, i32* %6
%592 = call i32 @do_arithm_eval(i8* %0, i32 %591, i32 %49, i32* %8)
%593 = icmp eq i32 %592, 0
br i1 %593, label %732, label %594
594: ; preds = %590
%595 = load i32, i32* %7
%596 = load i32, i32* %8
%597 = add nsw i32 %596, %595
store i32 %597, i32* %3
br label %732
598: ; preds = %583
%599 = call i64 @splice_infix(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)
%600 = icmp eq i64 %599, 0
br i1 %600, label %615, label %601
601: ; preds = %598
%602 = load i32, i32* %5
%603 = icmp eq i32 %602, %34
br i1 %603, label %615, label %604
604: ; preds = %601
%605 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %602, i32* %7)
%606 = icmp eq i32 %605, 0
br i1 %606, label %732, label %607
607: ; preds = %604
%608 = load i32, i32* %6
%609 = call i32 @do_arithm_eval(i8* %0, i32 %608, i32 %49, i32* %8)
%610 = icmp eq i32 %609, 0
br i1 %610, label %732, label %611
611: ; preds = %607
%612 = load i32, i32* %7
%613 = load i32, i32* %8
%614 = sub nsw i32 %612, %613
store i32 %614, i32* %3
br label %732
615: ; preds = %601, %598
%616 = call i64 @splice_infix(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)
%617 = icmp eq i64 %616, 0
br i1 %617, label %630, label %618
618: ; preds = %615
%619 = load i32, i32* %5
%620 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %619, i32* %7)
%621 = icmp eq i32 %620, 0
br i1 %621, label %732, label %622
622: ; preds = %618
%623 = load i32, i32* %6
%624 = call i32 @do_arithm_eval(i8* %0, i32 %623, i32 %49, i32* %8)
%625 = icmp eq i32 %624, 0
br i1 %625, label %732, label %626
626: ; preds = %622
%627 = load i32, i32* %7
%628 = load i32, i32* %8
%629 = mul nsw i32 %628, %627
store i32 %629, i32* %3
br label %732
630: ; preds = %615
%631 = call i64 @splice_infix(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)
%632 = icmp eq i64 %631, 0
br i1 %632, label %651, label %633
633: ; preds = %630
%634 = load i32, i32* %5
%635 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %634, i32* %7)
%636 = icmp eq i32 %635, 0
br i1 %636, label %732, label %637
637: ; preds = %633
%638 = load i32, i32* %6
%639 = call i32 @do_arithm_eval(i8* %0, i32 %638, i32 %49, i32* %8)
%640 = icmp eq i32 %639, 0
br i1 %640, label %732, label %641
641: ; preds = %637
%642 = load i32, i32* %8
%643 = icmp eq i32 %642, 0
br i1 %643, label %644, label %647
644: ; preds = %641
%645 = call i32 @bug(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.17, i64 0, i64 0))
%646 = load i32, i32* %8
br label %647
647: ; preds = %644, %641
%648 = phi i32 [ %646, %644 ], [ %642, %641 ]
%649 = load i32, i32* %7
%650 = sdiv i32 %649, %648
store i32 %650, i32* %3
br label %732
651: ; preds = %630
%652 = call i64 @splice_infix(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)
%653 = icmp eq i64 %652, 0
br i1 %653, label %672, label %654
654: ; preds = %651
%655 = load i32, i32* %5
%656 = call i32 @do_arithm_eval(i8* %0, i32 %34, i32 %655, i32* %7)
%657 = icmp eq i32 %656, 0
br i1 %657, label %732, label %658
658: ; preds = %654
%659 = load i32, i32* %6
%660 = call i32 @do_arithm_eval(i8* %0, i32 %659, i32 %49, i32* %8)
%661 = icmp eq i32 %660, 0
br i1 %661, label %732, label %662
662: ; preds = %658
%663 = load i32, i32* %8
%664 = icmp eq i32 %663, 0
br i1 %664, label %665, label %668
665: ; preds = %662
%666 = call i32 @bug(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.17, i64 0, i64 0))
%667 = load i32, i32* %8
br label %668
668: ; preds = %665, %662
%669 = phi i32 [ %667, %665 ], [ %663, %662 ]
%670 = load i32, i32* %7
%671 = srem i32 %670, %669
store i32 %671, i32* %3
br label %732
672: ; preds = %651
%673 = getelementptr inbounds i8, i8* %0, i64 %35
%674 = load i8, i8* %673
switch i8 %674, label %697 [
i8 126, label %675
i8 33, label %682
i8 45, label %690
]
675: ; preds = %672
%676 = add nsw i32 %34, 1
%677 = call i32 @do_arithm_eval(i8* %0, i32 %676, i32 %49, i32* %7)
%678 = icmp eq i32 %677, 0
br i1 %678, label %732, label %679
679: ; preds = %675
%680 = load i32, i32* %7
%681 = xor i32 %680, -1
store i32 %681, i32* %3
br label %732
682: ; preds = %672
%683 = add nsw i32 %34, 1
%684 = call i32 @do_arithm_eval(i8* %0, i32 %683, i32 %49, i32* %7)
%685 = icmp eq i32 %684, 0
br i1 %685, label %732, label %686
686: ; preds = %682
%687 = load i32, i32* %7
%688 = icmp eq i32 %687, 0
%689 = zext i1 %688 to i32
store i32 %689, i32* %3
br label %732
690: ; preds = %672
%691 = add nsw i32 %34, 1
%692 = call i32 @do_arithm_eval(i8* %0, i32 %691, i32 %49, i32* %7)
%693 = icmp eq i32 %692, 0
br i1 %693, label %732, label %694
694: ; preds = %690
%695 = load i32, i32* %7
%696 = sub nsw i32 0, %695
store i32 %696, i32* %3
br label %732
697: ; preds = %672
%698 = call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i64 0, i64 0))
%699 = call i32 @strncmp(i8* %673, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i64 0, i64 0), i32 %698)
%700 = icmp eq i32 %699, 0
br i1 %700, label %701, label %711
701: ; preds = %697
%702 = add nsw i32 %49, -1
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds i8, i8* %0, i64 %703
%705 = load i8, i8* %704
%706 = icmp eq i8 %705, 41
br i1 %706, label %707, label %732
707: ; preds = %701
%708 = call i32 @strlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.20, i64 0, i64 0))
%709 = add i32 %34, %708
%710 = sub i32 %49, %709
store i32 %710, i32* %3
br label %732
711: ; preds = %697
%712 = load i8, i8* %673
%713 = icmp eq i8 %712, 40
br i1 %713, label %714, label %723
714: ; preds = %711
%715 = add nsw i32 %49, -1
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds i8, i8* %0, i64 %716
%718 = load i8, i8* %717
%719 = icmp eq i8 %718, 41
br i1 %719, label %720, label %732
720: ; preds = %714
%721 = add nsw i32 %34, 1
%722 = call i32 @do_arithm_eval(i8* %0, i32 %721, i32 %715, i32* %3)
br label %732
723: ; preds = %711
%724 = sext i32 %49 to i64
%725 = getelementptr inbounds i8, i8* %0, i64 %724
%726 = load i8, i8* %725
store i8 0, i8* %725
%727 = call i64 @strtol(i8* %673, i8** %9, i32 0)
%728 = trunc i64 %727 to i32
store i32 %728, i32* %3
store i8 %726, i8* %725
%729 = load i8*, i8** %9
%730 = icmp eq i8* %729, %725
%731 = zext i1 %730 to i32
br label %732
732: ; preds = %714, %701, %690, %682, %675, %654, %658, %633, %637, %618, %622, %604, %607, %586, %590, %291, %310, %245, %238, %237, %186, %179, %178, %120, %124, %105, %109, %90, %94, %72, %76, %54, %58, %48, %723, %720, %707, %694, %686, %679, %668, %647, %626, %611, %594, %580, %513, %446, %379, %128, %113, %98, %80, %62
%733 = phi i32 [ 1, %62 ], [ 1, %80 ], [ 1, %98 ], [ 1, %113 ], [ 1, %128 ], [ 1, %379 ], [ 1, %446 ], [ 1, %513 ], [ 1, %580 ], [ 1, %594 ], [ 1, %611 ], [ 1, %626 ], [ 1, %647 ], [ 1, %668 ], [ 1, %679 ], [ 1, %686 ], [ 1, %694 ], [ 1, %707 ], [ %722, %720 ], [ %731, %723 ], [ 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 ], [ 1, %310 ], [ 1, %291 ], [ 0, %590 ], [ 0, %586 ], [ 0, %607 ], [ 0, %604 ], [ 0, %622 ], [ 0, %618 ], [ 0, %637 ], [ 0, %633 ], [ 0, %658 ], [ 0, %654 ], [ 0, %675 ], [ 0, %682 ], [ 0, %690 ], [ 0, %701 ], [ 0, %714 ]
ret i32 %733
}