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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ compare(char *, char *);
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
void check_expression_for_error(int argc, char **argv) {
  int i, status = 0, point_count = 0;
  char *ptr;
  if (argc == 1) {
    printf("Input error : Please enter some expression in the commandline.\n");
    exit(0);
  }
  if ((compare(argv[1], "+") == 0) || (compare(argv[1], "-") == 0) ||
      (compare(argv[1], "x") == 0) || (compare(argv[1], "/") == 0) ||
      (compare(argv[1], "%") == 0)) {
    printf("Input error : A number is expected at the begining of the "
           "expression.\n");
    exit(0);
  }
  if ((compare(argv[argc - 1], "+") == 0) ||
      (compare(argv[argc - 1], "-") == 0) ||
      (compare(argv[argc - 1], "x") == 0) ||
      (compare(argv[argc - 1], "/") == 0) ||
      (compare(argv[argc - 1], "%") == 0)) {
    printf(
        "Input error : A number is expected at the end of the expression.\n");
    exit(0);
  }
  for (i = 2; i < argc; i += 2) {
    if ((compare(argv[i], "+") != 0) && (compare(argv[i], "-") != 0) &&
        (compare(argv[i], "x") != 0) && (compare(argv[i], "/") != 0) &&
        (compare(argv[i], "%") != 0)) {
      printf("Input error : Location[%d] : %s : Any mathematical operator is "
             "expected. But found something else.\n",
             i, argv[i]);
      exit(0);
    }
  }
  for (i = 1; i < argc; i += 2) {
    if ((compare(argv[i], "+") == 0) || (compare(argv[i], "-") == 0) ||
        (compare(argv[i], "x") == 0) || (compare(argv[i], "/") == 0) ||
        (compare(argv[i], "%") == 0)) {
      printf("Input error : Location[%d] : %s : A number is expected. But "
             "found a mathematical operator.\n",
             i, argv[i]);
      exit(0);
    }
  }
  for (i = 1; i < argc; i += 2) {
    ptr = argv[i];
    point_count = 0;
    if ((*ptr == '^') || (*ptr == '-')) {
      ptr++;
    }
    for (; *ptr != '\0'; ptr++) {
      if ((*ptr < 48) || (*ptr > 57)) {
        if (*ptr == '-') {
          printf(
              "Input error : Location[%d] : %s : - sign is placed incorrectly. "
              "Remove the - sign or put two space around the - sign.\n",
              i, argv[i]);
          status = 1;
          break;
        } else if (*ptr == '^') {
          printf("Input error : Location[%d] : %s : Factorial sign can't be "
                 "used here. Remove the ^ sign.\n",
                 i, argv[i]);
          status = 1;
          break;
        } else if (*ptr == '.') {
          if (++point_count > 1) {
            printf("Input error : Location[%d] : %s : A floating number can't "
                   "have two points in it. Remove any one point.\n",
                   i, argv[i]);
            status = 1;
            break;
          }
          continue;
        } else {
          printf("Input error : Location[%d] : %s : Invalid number. A numbers "
                 "should't have any symobols other then digits.\n",
                 i, argv[i]);
          status = 1;
          break;
        }
      }
    }
  }
  if (status == 1) {
    exit(0);
  } else {
    printf("actual expression 	:= ");
    for (i = 1; i < argc; i++) {
      printf("%s ", argv[i]);
    }
    printf("\n");
  }
}


x86 assembly (clang, -O0):
<check_expression_for_error>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    116c <check_expression_for_error+0x3c>
lea    0xea2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xec5(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     1202 <check_expression_for_error+0xd2>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xea9(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     1202 <check_expression_for_error+0xd2>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe8d(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     1202 <check_expression_for_error+0xd2>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe71(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     1202 <check_expression_for_error+0xd2>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe55(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
jne    1217 <check_expression_for_error+0xe7>
lea    0xe41(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe11(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     12da <check_expression_for_error+0x1aa>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdec(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     12da <check_expression_for_error+0x1aa>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdc7(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     12da <check_expression_for_error+0x1aa>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xda2(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     12da <check_expression_for_error+0x1aa>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd7d(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
jne    12ef <check_expression_for_error+0x1bf>
lea    0xdb0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
movl   $0x2,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13e3 <check_expression_for_error+0x2b3>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd2b(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     13d0 <check_expression_for_error+0x2a0>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd0b(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     13d0 <check_expression_for_error+0x2a0>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xceb(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     13d0 <check_expression_for_error+0x2a0>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xccb(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     13d0 <check_expression_for_error+0x2a0>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xcab(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     13d0 <check_expression_for_error+0x2a0>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd11(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
jmp    13d5 <check_expression_for_error+0x2a5>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    12f6 <check_expression_for_error+0x1c6>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14d7 <check_expression_for_error+0x3a7>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc37(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     14a0 <check_expression_for_error+0x370>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc17(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     14a0 <check_expression_for_error+0x370>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbf7(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     14a0 <check_expression_for_error+0x370>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbd7(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
je     14a0 <check_expression_for_error+0x370>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbb7(%rip),%rsi
call   1050 <compare@plt>
cmp    $0x0,%rax
jne    14c4 <check_expression_for_error+0x394>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc81(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
jmp    14c9 <check_expression_for_error+0x399>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    13ea <check_expression_for_error+0x2ba>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1676 <check_expression_for_error+0x546>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5e,%eax
je     1521 <check_expression_for_error+0x3f1>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    152d <check_expression_for_error+0x3fd>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1532 <check_expression_for_error+0x402>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1663 <check_expression_for_error+0x533>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     1562 <check_expression_for_error+0x432>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jle    164d <check_expression_for_error+0x51d>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    159b <check_expression_for_error+0x46b>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc0b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x18(%rbp)
jmp    1663 <check_expression_for_error+0x533>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5e,%eax
jne    15d4 <check_expression_for_error+0x4a4>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc49(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x18(%rbp)
jmp    1663 <check_expression_for_error+0x533>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1624 <check_expression_for_error+0x4f4>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x1,%eax
jle    161f <check_expression_for_error+0x4ef>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc57(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x18(%rbp)
jmp    1663 <check_expression_for_error+0x533>
jmp    1652 <check_expression_for_error+0x522>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc91(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x18(%rbp)
jmp    1663 <check_expression_for_error+0x533>
jmp    1652 <check_expression_for_error+0x522>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1532 <check_expression_for_error+0x402>
jmp    1668 <check_expression_for_error+0x538>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    14de <check_expression_for_error+0x3ae>
cmpl   $0x1,-0x18(%rbp)
jne    1687 <check_expression_for_error+0x557>
xor    %edi,%edi
call   1040 <exit@plt>
lea    0xca8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16d0 <check_expression_for_error+0x5a0>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0xc92(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    169c <check_expression_for_error+0x56c>
lea    0x967(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_expression_for_error>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
cmp    $0x1,%edi
je     1540 <check_expression_for_error+0x3f0>
mov    %rsi,%rbx
mov    %edi,%r14d
mov    0x8(%rsi),%rdi
lea    0xe88(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1524 <check_expression_for_error+0x3d4>
mov    0x8(%rbx),%rdi
lea    0xe71(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1524 <check_expression_for_error+0x3d4>
mov    0x8(%rbx),%rdi
lea    0xe5a(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1524 <check_expression_for_error+0x3d4>
mov    0x8(%rbx),%rdi
lea    0xe43(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1524 <check_expression_for_error+0x3d4>
mov    0x8(%rbx),%rdi
lea    0xe2c(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1524 <check_expression_for_error+0x3d4>
movslq %r14d,%rbp
mov    -0x8(%rbx,%rbp,8),%rdi
lea    0xe07(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     152d <check_expression_for_error+0x3dd>
add    $0xffffffffffffffff,%rbp
mov    (%rbx,%rbp,8),%rdi
lea    0xdec(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     152d <check_expression_for_error+0x3dd>
mov    (%rbx,%rbp,8),%rdi
lea    0xdd5(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     152d <check_expression_for_error+0x3dd>
mov    (%rbx,%rbp,8),%rdi
lea    0xdbe(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     152d <check_expression_for_error+0x3dd>
mov    (%rbx,%rbp,8),%rdi
lea    0xda7(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     152d <check_expression_for_error+0x3dd>
cmp    $0x3,%r14d
jl     1316 <check_expression_for_error+0x1c6>
mov    $0x2,%ebp
lea    0xd7b(%rip),%r15
lea    0xd76(%rip),%r12
lea    0xd71(%rip),%r13
jmp    12a9 <check_expression_for_error+0x159>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rbp
cmp    %r14d,%ebp
jge    1316 <check_expression_for_error+0x1c6>
mov    (%rbx,%rbp,8),%rdi
mov    %r15,%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     12a0 <check_expression_for_error+0x150>
mov    (%rbx,%rbp,8),%rdi
mov    %r12,%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     12a0 <check_expression_for_error+0x150>
mov    (%rbx,%rbp,8),%rdi
mov    %r13,%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     12a0 <check_expression_for_error+0x150>
mov    (%rbx,%rbp,8),%rdi
lea    0xd1f(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     12a0 <check_expression_for_error+0x150>
mov    (%rbx,%rbp,8),%rdi
lea    0xd0c(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     12a0 <check_expression_for_error+0x150>
mov    (%rbx,%rbp,8),%rdx
lea    0xcf9(%rip),%rdi
jmp    1514 <check_expression_for_error+0x3c4>
cmp    $0x2,%r14d
jl     148d <check_expression_for_error+0x33d>
mov    %r14d,0xc(%rsp)
mov    %r14d,%eax
mov    %rax,0x10(%rsp)
mov    $0x1,%ebp
lea    0xcc9(%rip),%r12
lea    0xcc4(%rip),%r13
lea    0xcbf(%rip),%r14
lea    0xcba(%rip),%r15
xchg   %ax,%ax
mov    (%rbx,%rbp,8),%rdi
lea    0xca5(%rip),%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1509 <check_expression_for_error+0x3b9>
mov    (%rbx,%rbp,8),%rdi
mov    %r12,%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1509 <check_expression_for_error+0x3b9>
mov    (%rbx,%rbp,8),%rdi
mov    %r13,%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1509 <check_expression_for_error+0x3b9>
mov    (%rbx,%rbp,8),%rdi
mov    %r14,%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1509 <check_expression_for_error+0x3b9>
mov    (%rbx,%rbp,8),%rdi
mov    %r15,%rsi
call   1070 <compare@plt>
test   %rax,%rax
je     1509 <check_expression_for_error+0x3b9>
add    $0x2,%rbp
cmp    0x10(%rsp),%rbp
jb     1350 <check_expression_for_error+0x200>
cmpl   $0x2,0xc(%rsp)
jl     148d <check_expression_for_error+0x33d>
mov    $0x1,%ebp
lea    0xceb(%rip),%r14
lea    0xdb4(%rip),%r15
lea    0xd54(%rip),%r12
lea    0xe0e(%rip),%r13
xor    %r8d,%r8d
jmp    1419 <check_expression_for_error+0x2c9>
mov    %r13,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%r8d
add    $0x2,%rbp
cmp    0xc(%rsp),%ebp
jge    14b3 <check_expression_for_error+0x363>
mov    (%rbx,%rbp,8),%rdx
mov    (%rdx),%cl
cmp    $0x5e,%cl
je     142c <check_expression_for_error+0x2dc>
mov    %rdx,%rsi
cmp    $0x2d,%cl
jne    1433 <check_expression_for_error+0x2e3>
lea    0x1(%rdx),%rsi
mov    0x1(%rdx),%cl
test   %cl,%cl
je     140b <check_expression_for_error+0x2bb>
add    $0x1,%rsi
xor    %edi,%edi
jmp    144b <check_expression_for_error+0x2fb>
nop
movzbl (%rsi),%ecx
add    $0x1,%rsi
test   %cl,%cl
je     140b <check_expression_for_error+0x2bb>
lea    -0x3a(%rcx),%eax
cmp    $0xf5,%al
ja     1440 <check_expression_for_error+0x2f0>
cmp    $0x2e,%cl
jne    1470 <check_expression_for_error+0x320>
test   %edi,%edi
mov    $0x1,%edi
jle    1440 <check_expression_for_error+0x2f0>
mov    %r15,%rdi
jmp    13fc <check_expression_for_error+0x2ac>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%rdi
cmp    $0x2d,%cl
je     13fc <check_expression_for_error+0x2ac>
cmp    $0x5e,%cl
jne    13f9 <check_expression_for_error+0x2a9>
mov    %r12,%rdi
jmp    13fc <check_expression_for_error+0x2ac>
lea    0xdd9(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <putchar@plt>
cmp    $0x1,%r8d
je     1549 <check_expression_for_error+0x3f9>
lea    0xda9(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x2,0xc(%rsp)
mov    0x10(%rsp),%r15
jl     149b <check_expression_for_error+0x34b>
mov    $0x1,%ebp
lea    0xda1(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rbp,8),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r15
jne    14f0 <check_expression_for_error+0x3a0>
jmp    149b <check_expression_for_error+0x34b>
mov    (%rbx,%rbp,8),%rdx
lea    0xb5a(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %edi,%edi
call   1060 <exit@plt>
lea    0xd9e(%rip),%rdi
jmp    1534 <check_expression_for_error+0x3e4>
lea    0xd54(%rip),%rdi
call   1040 <puts@plt>
xor    %edi,%edi
call   1060 <exit@plt>
lea    0xdc8(%rip),%rdi
jmp    1534 <check_expression_for_error+0x3e4>
xor    %edi,%edi
call   1060 <exit@plt>

LLVM IR (-O0):
@.str = [64 x i8] c"Input error : Please enter some expression in the commandline.\0A\00"
@.str.1 = [2 x i8] c"+\00"
@.str.2 = [2 x i8] c"-\00"
@.str.3 = [2 x i8] c"x\00"
@.str.4 = [2 x i8] c"/\00"
@.str.5 = [2 x i8] c"%\00"
@.str.6 = [71 x i8] c"Input error : A number is expected at the begining of the expression.\0A\00"
@.str.7 = [66 x i8] c"Input error : A number is expected at the end of the expression.\0A\00"
@.str.8 = [100 x i8] c"Input error : Location[%d] : %s : Any mathematical operator is expected. But found something else.\0A\00"
@.str.9 = [92 x i8] c"Input error : Location[%d] : %s : A number is expected. But found a mathematical operator.\0A\00"
@.str.10 = [119 x i8] c"Input error : Location[%d] : %s : - sign is placed incorrectly. Remove the - sign or put two space around the - sign.\0A\00"
@.str.11 = [89 x i8] c"Input error : Location[%d] : %s : Factorial sign can't be used here. Remove the ^ sign.\0A\00"
@.str.12 = [104 x i8] c"Input error : Location[%d] : %s : A floating number can't have two points in it. Remove any one point.\0A\00"
@.str.13 = [107 x i8] c"Input error : Location[%d] : %s : Invalid number. A numbers should't have any symobols other then digits.\0A\00"
@.str.14 = [23 x i8] c"actual expression \09:= \00"
@.str.15 = [4 x i8] c"%s \00"
@.str.16 = [2 x i8] c"\0A\00"
define void @check_expression_for_error(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
store i32 %0, i32* %3
store i8** %1, i8*** %4
store i32 0, i32* %6
store i32 0, i32* %7
%9 = load i32, i32* %3
%10 = icmp eq i32 %9, 1
br i1 %10, label %11, label %14
11: ; preds = %2
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str, i64 0, i64 0))
%13 = call i32 @exit(i32 0)
unreachable
14: ; preds = %2
%15 = load i8**, i8*** %4
%16 = getelementptr inbounds i8*, i8** %15, i64 1
%17 = load i8*, i8** %16
%18 = call i64 @compare(i8* %17, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%19 = icmp eq i64 %18, 0
br i1 %19, label %44, label %20
20: ; preds = %14
%21 = load i8**, i8*** %4
%22 = getelementptr inbounds i8*, i8** %21, i64 1
%23 = load i8*, i8** %22
%24 = call i64 @compare(i8* %23, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%25 = icmp eq i64 %24, 0
br i1 %25, label %44, label %26
26: ; preds = %20
%27 = load i8**, i8*** %4
%28 = getelementptr inbounds i8*, i8** %27, i64 1
%29 = load i8*, i8** %28
%30 = call i64 @compare(i8* %29, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%31 = icmp eq i64 %30, 0
br i1 %31, label %44, label %32
32: ; preds = %26
%33 = load i8**, i8*** %4
%34 = getelementptr inbounds i8*, i8** %33, i64 1
%35 = load i8*, i8** %34
%36 = call i64 @compare(i8* %35, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%37 = icmp eq i64 %36, 0
br i1 %37, label %44, label %38
38: ; preds = %32
%39 = load i8**, i8*** %4
%40 = getelementptr inbounds i8*, i8** %39, i64 1
%41 = load i8*, i8** %40
%42 = call i64 @compare(i8* %41, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%43 = icmp eq i64 %42, 0
br i1 %43, label %44, label %47
44: ; preds = %38, %32, %26, %20, %14
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.6, i64 0, i64 0))
%46 = call i32 @exit(i32 0)
unreachable
47: ; preds = %38
%48 = load i8**, i8*** %4
%49 = load i32, i32* %3
%50 = sub nsw i32 %49, 1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i8*, i8** %48, i64 %51
%53 = load i8*, i8** %52
%54 = call i64 @compare(i8* %53, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%55 = icmp eq i64 %54, 0
br i1 %55, label %92, label %56
56: ; preds = %47
%57 = load i8**, i8*** %4
%58 = load i32, i32* %3
%59 = sub nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8*, i8** %57, i64 %60
%62 = load i8*, i8** %61
%63 = call i64 @compare(i8* %62, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%64 = icmp eq i64 %63, 0
br i1 %64, label %92, label %65
65: ; preds = %56
%66 = load i8**, i8*** %4
%67 = load i32, i32* %3
%68 = sub nsw i32 %67, 1
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8*, i8** %66, i64 %69
%71 = load i8*, i8** %70
%72 = call i64 @compare(i8* %71, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%73 = icmp eq i64 %72, 0
br i1 %73, label %92, label %74
74: ; preds = %65
%75 = load i8**, i8*** %4
%76 = load i32, i32* %3
%77 = sub nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i8*, i8** %75, i64 %78
%80 = load i8*, i8** %79
%81 = call i64 @compare(i8* %80, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%82 = icmp eq i64 %81, 0
br i1 %82, label %92, label %83
83: ; preds = %74
%84 = load i8**, i8*** %4
%85 = load i32, i32* %3
%86 = sub nsw i32 %85, 1
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i8*, i8** %84, i64 %87
%89 = load i8*, i8** %88
%90 = call i64 @compare(i8* %89, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%91 = icmp eq i64 %90, 0
br i1 %91, label %92, label %95
92: ; preds = %83, %74, %65, %56, %47
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.7, i64 0, i64 0))
%94 = call i32 @exit(i32 0)
unreachable
95: ; preds = %83
store i32 2, i32* %5
br label %96
96: ; preds = %150, %95
%97 = load i32, i32* %5
%98 = load i32, i32* %3
%99 = icmp slt i32 %97, %98
br i1 %99, label %100, label %153
100: ; preds = %96
%101 = load i8**, i8*** %4
%102 = load i32, i32* %5
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i8*, i8** %101, i64 %103
%105 = load i8*, i8** %104
%106 = call i64 @compare(i8* %105, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%107 = icmp ne i64 %106, 0
br i1 %107, label %108, label %149
108: ; preds = %100
%109 = load i8**, i8*** %4
%110 = load i32, i32* %5
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i8*, i8** %109, i64 %111
%113 = load i8*, i8** %112
%114 = call i64 @compare(i8* %113, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%115 = icmp ne i64 %114, 0
br i1 %115, label %116, label %149
116: ; preds = %108
%117 = load i8**, i8*** %4
%118 = load i32, i32* %5
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8*, i8** %117, i64 %119
%121 = load i8*, i8** %120
%122 = call i64 @compare(i8* %121, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%123 = icmp ne i64 %122, 0
br i1 %123, label %124, label %149
124: ; preds = %116
%125 = load i8**, i8*** %4
%126 = load i32, i32* %5
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8*, i8** %125, i64 %127
%129 = load i8*, i8** %128
%130 = call i64 @compare(i8* %129, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%131 = icmp ne i64 %130, 0
br i1 %131, label %132, label %149
132: ; preds = %124
%133 = load i8**, i8*** %4
%134 = load i32, i32* %5
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i8*, i8** %133, i64 %135
%137 = load i8*, i8** %136
%138 = call i64 @compare(i8* %137, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%139 = icmp ne i64 %138, 0
br i1 %139, label %140, label %149
140: ; preds = %132
%141 = load i32, i32* %5
%142 = load i8**, i8*** %4
%143 = load i32, i32* %5
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i8*, i8** %142, i64 %144
%146 = load i8*, i8** %145
%147 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.8, i64 0, i64 0), i32 %141, i8* %146)
%148 = call i32 @exit(i32 0)
unreachable
149: ; preds = %132, %124, %116, %108, %100
br label %150
150: ; preds = %149
%151 = load i32, i32* %5
%152 = add nsw i32 %151, 2
store i32 %152, i32* %5
br label %96
153: ; preds = %96
store i32 1, i32* %5
br label %154
154: ; preds = %208, %153
%155 = load i32, i32* %5
%156 = load i32, i32* %3
%157 = icmp slt i32 %155, %156
br i1 %157, label %158, label %211
158: ; preds = %154
%159 = load i8**, i8*** %4
%160 = load i32, i32* %5
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i8*, i8** %159, i64 %161
%163 = load i8*, i8** %162
%164 = call i64 @compare(i8* %163, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%165 = icmp eq i64 %164, 0
br i1 %165, label %198, label %166
166: ; preds = %158
%167 = load i8**, i8*** %4
%168 = load i32, i32* %5
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i8*, i8** %167, i64 %169
%171 = load i8*, i8** %170
%172 = call i64 @compare(i8* %171, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%173 = icmp eq i64 %172, 0
br i1 %173, label %198, label %174
174: ; preds = %166
%175 = load i8**, i8*** %4
%176 = load i32, i32* %5
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i8*, i8** %175, i64 %177
%179 = load i8*, i8** %178
%180 = call i64 @compare(i8* %179, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%181 = icmp eq i64 %180, 0
br i1 %181, label %198, label %182
182: ; preds = %174
%183 = load i8**, i8*** %4
%184 = load i32, i32* %5
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i8*, i8** %183, i64 %185
%187 = load i8*, i8** %186
%188 = call i64 @compare(i8* %187, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%189 = icmp eq i64 %188, 0
br i1 %189, label %198, label %190
190: ; preds = %182
%191 = load i8**, i8*** %4
%192 = load i32, i32* %5
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8*, i8** %191, i64 %193
%195 = load i8*, i8** %194
%196 = call i64 @compare(i8* %195, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%197 = icmp eq i64 %196, 0
br i1 %197, label %198, label %207
198: ; preds = %190, %182, %174, %166, %158
%199 = load i32, i32* %5
%200 = load i8**, i8*** %4
%201 = load i32, i32* %5
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i8*, i8** %200, i64 %202
%204 = load i8*, i8** %203
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.9, i64 0, i64 0), i32 %199, i8* %204)
%206 = call i32 @exit(i32 0)
unreachable
207: ; preds = %190
br label %208
208: ; preds = %207
%209 = load i32, i32* %5
%210 = add nsw i32 %209, 2
store i32 %210, i32* %5
br label %154
211: ; preds = %154
store i32 1, i32* %5
br label %212
212: ; preds = %307, %211
%213 = load i32, i32* %5
%214 = load i32, i32* %3
%215 = icmp slt i32 %213, %214
br i1 %215, label %216, label %310
216: ; preds = %212
%217 = load i8**, i8*** %4
%218 = load i32, i32* %5
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i8*, i8** %217, i64 %219
%221 = load i8*, i8** %220
store i8* %221, i8** %8
store i32 0, i32* %7
%222 = load i8*, i8** %8
%223 = load i8, i8* %222
%224 = sext i8 %223 to i32
%225 = icmp eq i32 %224, 94
br i1 %225, label %231, label %226
226: ; preds = %216
%227 = load i8*, i8** %8
%228 = load i8, i8* %227
%229 = sext i8 %228 to i32
%230 = icmp eq i32 %229, 45
br i1 %230, label %231, label %234
231: ; preds = %226, %216
%232 = load i8*, i8** %8
%233 = getelementptr inbounds i8, i8* %232, i32 1
store i8* %233, i8** %8
br label %234
234: ; preds = %231, %226
br label %235
235: ; preds = %303, %234
%236 = load i8*, i8** %8
%237 = load i8, i8* %236
%238 = sext i8 %237 to i32
%239 = icmp ne i32 %238, 0
br i1 %239, label %240, label %306
240: ; preds = %235
%241 = load i8*, i8** %8
%242 = load i8, i8* %241
%243 = sext i8 %242 to i32
%244 = icmp slt i32 %243, 48
br i1 %244, label %250, label %245
245: ; preds = %240
%246 = load i8*, i8** %8
%247 = load i8, i8* %246
%248 = sext i8 %247 to i32
%249 = icmp sgt i32 %248, 57
br i1 %249, label %250, label %302
250: ; preds = %245, %240
%251 = load i8*, i8** %8
%252 = load i8, i8* %251
%253 = sext i8 %252 to i32
%254 = icmp eq i32 %253, 45
br i1 %254, label %255, label %263
255: ; preds = %250
%256 = load i32, i32* %5
%257 = load i8**, i8*** %4
%258 = load i32, i32* %5
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i8*, i8** %257, i64 %259
%261 = load i8*, i8** %260
%262 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([119 x i8], [119 x i8]* @.str.10, i64 0, i64 0), i32 %256, i8* %261)
store i32 1, i32* %6
br label %306
263: ; preds = %250
%264 = load i8*, i8** %8
%265 = load i8, i8* %264
%266 = sext i8 %265 to i32
%267 = icmp eq i32 %266, 94
br i1 %267, label %268, label %276
268: ; preds = %263
%269 = load i32, i32* %5
%270 = load i8**, i8*** %4
%271 = load i32, i32* %5
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i8*, i8** %270, i64 %272
%274 = load i8*, i8** %273
%275 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.11, i64 0, i64 0), i32 %269, i8* %274)
store i32 1, i32* %6
br label %306
276: ; preds = %263
%277 = load i8*, i8** %8
%278 = load i8, i8* %277
%279 = sext i8 %278 to i32
%280 = icmp eq i32 %279, 46
br i1 %280, label %281, label %294
281: ; preds = %276
%282 = load i32, i32* %7
%283 = add nsw i32 %282, 1
store i32 %283, i32* %7
%284 = icmp sgt i32 %283, 1
br i1 %284, label %285, label %293
285: ; preds = %281
%286 = load i32, i32* %5
%287 = load i8**, i8*** %4
%288 = load i32, i32* %5
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i8*, i8** %287, i64 %289
%291 = load i8*, i8** %290
%292 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.12, i64 0, i64 0), i32 %286, i8* %291)
store i32 1, i32* %6
br label %306
293: ; preds = %281
br label %303
294: ; preds = %276
%295 = load i32, i32* %5
%296 = load i8**, i8*** %4
%297 = load i32, i32* %5
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i8*, i8** %296, i64 %298
%300 = load i8*, i8** %299
%301 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.13, i64 0, i64 0), i32 %295, i8* %300)
store i32 1, i32* %6
br label %306
302: ; preds = %245
br label %303
303: ; preds = %302, %293
%304 = load i8*, i8** %8
%305 = getelementptr inbounds i8, i8* %304, i32 1
store i8* %305, i8** %8
br label %235
306: ; preds = %294, %285, %268, %255, %235
br label %307
307: ; preds = %306
%308 = load i32, i32* %5
%309 = add nsw i32 %308, 2
store i32 %309, i32* %5
br label %212
310: ; preds = %212
%311 = load i32, i32* %6
%312 = icmp eq i32 %311, 1
br i1 %312, label %313, label %315
313: ; preds = %310
%314 = call i32 @exit(i32 0)
unreachable
315: ; preds = %310
%316 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.14, i64 0, i64 0))
store i32 1, i32* %5
br label %317
317: ; preds = %328, %315
%318 = load i32, i32* %5
%319 = load i32, i32* %3
%320 = icmp slt i32 %318, %319
br i1 %320, label %321, label %331
321: ; preds = %317
%322 = load i8**, i8*** %4
%323 = load i32, i32* %5
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i8*, i8** %322, i64 %324
%326 = load i8*, i8** %325
%327 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0), i8* %326)
br label %328
328: ; preds = %321
%329 = load i32, i32* %5
%330 = add nsw i32 %329, 1
store i32 %330, i32* %5
br label %317
331: ; preds = %317
%332 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
br label %333
333: ; preds = %331
ret void
}

LLVM IR (-O2):
@.str.1 = [2 x i8] c"+\00"
@.str.2 = [2 x i8] c"-\00"
@.str.3 = [2 x i8] c"x\00"
@.str.4 = [2 x i8] c"/\00"
@.str.5 = [2 x i8] c"%\00"
@.str.8 = [100 x i8] c"Input error : Location[%d] : %s : Any mathematical operator is expected. But found something else.\0A\00"
@.str.9 = [92 x i8] c"Input error : Location[%d] : %s : A number is expected. But found a mathematical operator.\0A\00"
@.str.10 = [119 x i8] c"Input error : Location[%d] : %s : - sign is placed incorrectly. Remove the - sign or put two space around the - sign.\0A\00"
@.str.11 = [89 x i8] c"Input error : Location[%d] : %s : Factorial sign can't be used here. Remove the ^ sign.\0A\00"
@.str.12 = [104 x i8] c"Input error : Location[%d] : %s : A floating number can't have two points in it. Remove any one point.\0A\00"
@.str.13 = [107 x i8] c"Input error : Location[%d] : %s : Invalid number. A numbers should't have any symobols other then digits.\0A\00"
@.str.14 = [23 x i8] c"actual expression \09:= \00"
@.str.15 = [4 x i8] c"%s \00"
@str = [65 x i8] c"Input error : A number is expected at the end of the expression.\00"
@str.17 = [70 x i8] c"Input error : A number is expected at the begining of the expression.\00"
@str.18 = [63 x i8] c"Input error : Please enter some expression in the commandline.\00"
define void @check_expression_for_error(i32 %0, i8** nocapture %1) {
%3 = icmp eq i32 %0, 1
br i1 %3, label %4, label %7
4: ; preds = %2
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.18, i64 0, i64 0))
%6 = tail call i32 @exit(i32 0)
unreachable
7: ; preds = %2
%8 = getelementptr inbounds i8*, i8** %1, i64 1
%9 = load i8*, i8** %8
%10 = tail call i64 @compare(i8* %9, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%11 = icmp eq i64 %10, 0
br i1 %11, label %28, label %12
12: ; preds = %7
%13 = load i8*, i8** %8
%14 = tail call i64 @compare(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%15 = icmp eq i64 %14, 0
br i1 %15, label %28, label %16
16: ; preds = %12
%17 = load i8*, i8** %8
%18 = tail call i64 @compare(i8* %17, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%19 = icmp eq i64 %18, 0
br i1 %19, label %28, label %20
20: ; preds = %16
%21 = load i8*, i8** %8
%22 = tail call i64 @compare(i8* %21, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%23 = icmp eq i64 %22, 0
br i1 %23, label %28, label %24
24: ; preds = %20
%25 = load i8*, i8** %8
%26 = tail call i64 @compare(i8* %25, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%27 = icmp eq i64 %26, 0
br i1 %27, label %28, label %31
28: ; preds = %24, %20, %16, %12, %7
%29 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.17, i64 0, i64 0))
%30 = tail call i32 @exit(i32 0)
unreachable
31: ; preds = %24
%32 = add nsw i32 %0, -1
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8*, i8** %1, i64 %33
%35 = load i8*, i8** %34
%36 = tail call i64 @compare(i8* %35, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%37 = icmp eq i64 %36, 0
br i1 %37, label %56, label %38
38: ; preds = %31
%39 = load i8*, i8** %34
%40 = tail call i64 @compare(i8* %39, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%41 = icmp eq i64 %40, 0
br i1 %41, label %56, label %42
42: ; preds = %38
%43 = load i8*, i8** %34
%44 = tail call i64 @compare(i8* %43, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%45 = icmp eq i64 %44, 0
br i1 %45, label %56, label %46
46: ; preds = %42
%47 = load i8*, i8** %34
%48 = tail call i64 @compare(i8* %47, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%49 = icmp eq i64 %48, 0
br i1 %49, label %56, label %50
50: ; preds = %46
%51 = load i8*, i8** %34
%52 = tail call i64 @compare(i8* %51, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%53 = icmp eq i64 %52, 0
br i1 %53, label %56, label %54
54: ; preds = %50
%55 = icmp sgt i32 %0, 2
br i1 %55, label %63, label %59
56: ; preds = %50, %46, %42, %38, %31
%57 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str, i64 0, i64 0))
%58 = tail call i32 @exit(i32 0)
unreachable
59: ; preds = %90, %54
%60 = icmp sgt i32 %0, 1
br i1 %60, label %61, label %164
61: ; preds = %59
%62 = zext i32 %0 to i64
br label %95
63: ; preds = %54, %90
%64 = phi i64 [ %91, %90 ], [ 2, %54 ]
%65 = getelementptr inbounds i8*, i8** %1, i64 %64
%66 = load i8*, i8** %65
%67 = tail call i64 @compare(i8* %66, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%68 = icmp eq i64 %67, 0
br i1 %68, label %90, label %69
69: ; preds = %63
%70 = load i8*, i8** %65
%71 = tail call i64 @compare(i8* %70, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%72 = icmp eq i64 %71, 0
br i1 %72, label %90, label %73
73: ; preds = %69
%74 = load i8*, i8** %65
%75 = tail call i64 @compare(i8* %74, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%76 = icmp eq i64 %75, 0
br i1 %76, label %90, label %77
77: ; preds = %73
%78 = load i8*, i8** %65
%79 = tail call i64 @compare(i8* %78, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%80 = icmp eq i64 %79, 0
br i1 %80, label %90, label %81
81: ; preds = %77
%82 = load i8*, i8** %65
%83 = tail call i64 @compare(i8* %82, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%84 = icmp eq i64 %83, 0
br i1 %84, label %90, label %85
85: ; preds = %81
%86 = trunc i64 %64 to i32
%87 = load i8*, i8** %65
%88 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([100 x i8], [100 x i8]* @.str.8, i64 0, i64 0), i32 %86, i8* %87)
%89 = tail call i32 @exit(i32 0)
unreachable
90: ; preds = %63, %69, %73, %77, %81
%91 = add nuw i64 %64, 2
%92 = trunc i64 %91 to i32
%93 = icmp slt i32 %92, %0
br i1 %93, label %63, label %59
94: ; preds = %122
br i1 %60, label %125, label %164
95: ; preds = %61, %122
%96 = phi i64 [ 1, %61 ], [ %123, %122 ]
%97 = getelementptr inbounds i8*, i8** %1, i64 %96
%98 = load i8*, i8** %97
%99 = tail call i64 @compare(i8* %98, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%100 = icmp eq i64 %99, 0
br i1 %100, label %117, label %101
101: ; preds = %95
%102 = load i8*, i8** %97
%103 = tail call i64 @compare(i8* %102, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%104 = icmp eq i64 %103, 0
br i1 %104, label %117, label %105
105: ; preds = %101
%106 = load i8*, i8** %97
%107 = tail call i64 @compare(i8* %106, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%108 = icmp eq i64 %107, 0
br i1 %108, label %117, label %109
109: ; preds = %105
%110 = load i8*, i8** %97
%111 = tail call i64 @compare(i8* %110, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%112 = icmp eq i64 %111, 0
br i1 %112, label %117, label %113
113: ; preds = %109
%114 = load i8*, i8** %97
%115 = tail call i64 @compare(i8* %114, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%116 = icmp eq i64 %115, 0
br i1 %116, label %117, label %122
117: ; preds = %113, %109, %105, %101, %95
%118 = trunc i64 %96 to i32
%119 = load i8*, i8** %97
%120 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([92 x i8], [92 x i8]* @.str.9, i64 0, i64 0), i32 %118, i8* %119)
%121 = tail call i32 @exit(i32 0)
unreachable
122: ; preds = %113
%123 = add nuw nsw i64 %96, 2
%124 = icmp ult i64 %123, %62
br i1 %124, label %95, label %94
125: ; preds = %94, %159
%126 = phi i64 [ %161, %159 ], [ 1, %94 ]
%127 = phi i32 [ %160, %159 ], [ 0, %94 ]
%128 = getelementptr inbounds i8*, i8** %1, i64 %126
%129 = load i8*, i8** %128
%130 = load i8, i8* %129
switch i8 %130, label %134 [
i8 94, label %131
i8 45, label %131
]
131: ; preds = %125, %125
%132 = getelementptr inbounds i8, i8* %129, i64 1
%133 = load i8, i8* %132
br label %134
134: ; preds = %125, %131
%135 = phi i8 [ %133, %131 ], [ %130, %125 ]
%136 = phi i8* [ %132, %131 ], [ %129, %125 ]
%137 = icmp eq i8 %135, 0
br i1 %137, label %159, label %138
138: ; preds = %134, %147
%139 = phi i8 [ %150, %147 ], [ %135, %134 ]
%140 = phi i8* [ %149, %147 ], [ %136, %134 ]
%141 = phi i32 [ %148, %147 ], [ 0, %134 ]
%142 = add i8 %139, -58
%143 = icmp ult i8 %142, -10
br i1 %143, label %144, label %147
144: ; preds = %138
switch i8 %139, label %155 [
i8 45, label %152
i8 94, label %154
i8 46, label %145
]
145: ; preds = %144
%146 = icmp sgt i32 %141, 0
br i1 %146, label %152, label %147
147: ; preds = %138, %145
%148 = phi i32 [ 1, %145 ], [ %141, %138 ]
%149 = getelementptr inbounds i8, i8* %140, i64 1
%150 = load i8, i8* %149
%151 = icmp eq i8 %150, 0
br i1 %151, label %159, label %138
152: ; preds = %144, %145
%153 = phi i8* [ getelementptr inbounds ([104 x i8], [104 x i8]* @.str.12, i64 0, i64 0), %145 ], [ getelementptr inbounds ([119 x i8], [119 x i8]* @.str.10, i64 0, i64 0), %144 ]
br label %155
154: ; preds = %144
br label %155
155: ; preds = %144, %154, %152
%156 = phi i8* [ %153, %152 ], [ getelementptr inbounds ([89 x i8], [89 x i8]* @.str.11, i64 0, i64 0), %154 ], [ getelementptr inbounds ([107 x i8], [107 x i8]* @.str.13, i64 0, i64 0), %144 ]
%157 = trunc i64 %126 to i32
%158 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) %156, i32 %157, i8* %129)
br label %159
159: ; preds = %147, %155, %134
%160 = phi i32 [ %127, %134 ], [ 1, %155 ], [ %127, %147 ]
%161 = add nuw i64 %126, 2
%162 = trunc i64 %161 to i32
%163 = icmp slt i32 %162, %0
br i1 %163, label %125, label %166
164: ; preds = %59, %94
%165 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.14, i64 0, i64 0))
br label %181
166: ; preds = %159
%167 = icmp eq i32 %160, 1
br i1 %167, label %168, label %170
168: ; preds = %166
%169 = tail call i32 @exit(i32 0)
unreachable
170: ; preds = %166
%171 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.14, i64 0, i64 0))
br i1 %60, label %172, label %181
172: ; preds = %170
%173 = zext i32 %0 to i64
br label %174
174: ; preds = %172, %174
%175 = phi i64 [ 1, %172 ], [ %179, %174 ]
%176 = getelementptr inbounds i8*, i8** %1, i64 %175
%177 = load i8*, i8** %176
%178 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0), i8* %177)
%179 = add nuw nsw i64 %175, 1
%180 = icmp eq i64 %179, %173
br i1 %180, label %181, label %174
181: ; preds = %174, %164, %170
%182 = tail call i32 @putchar(i32 10)
ret void
}