#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*/ memcmp(char *, char *, int);
int /*<<< orphan*/ memcpy(char *, char *, int);
int option_match(char *, char *);
int /*<<< orphan*/ printf(char *, ...);
int strlen(char *);
char *strstr(char *, char *);
int proc_tag(char **opos, int olen, char **npos, int *nlen, char *optfile) {
  char *blk_end, *optn, *optb;
  int inverse;
  int clen = 0;
  char *oend = *opos + olen;
  char *next_end, *next_opt;
  while (*opos < oend) {
    if (!memcmp(*opos, "/*DEMO*/", strlen("/*DEMO*/"))) {
      if ((blk_end = strstr(*opos, "/*END_DEMO*/")) == NULL) {
        printf("can not find %s\n", "/*END_DEMO*/");
        return -1;
      }
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      *opos = blk_end + strlen("/*END_DEMO*/");
      clen = 0;
    } else if (!memcmp(*opos, "<!--DO_CGI", strlen("<!--DO_CGI"))) {
      if ((blk_end = strstr(*opos, "DO_CGI-->")) == NULL) {
        printf("can not find %s\n", "DO_CGI-->");
        return -1;
      }
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      *opos = blk_end + strlen("DO_CGI-->");
      clen = 0;
    } else if (!memcmp(*opos, "<!--DEMO-->", strlen("<!--DEMO-->"))) {
      if ((blk_end = strstr(*opos, "<!--END_DEMO-->")) == NULL) {
        printf("can not find %s\n", "<!--END_DEMO-->");
        return -1;
      }
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      *opos = blk_end + strlen("<!--END_DEMO-->");
      clen = 0;
    } else if (!memcmp(*opos, "/*REAL", strlen("/*REAL"))) {
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      *opos += strlen("/*REAL");
      clen = 0;
    } else if (!memcmp(*opos, "REAL*/", strlen("REAL*/"))) {
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      *opos += strlen("REAL*/");
      clen = 0;
    } else if (!memcmp(*opos, "<!--REAL", strlen("<!--REAL"))) {
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      *opos += strlen("<!--REAL");
      clen = 0;
    } else if (!memcmp(*opos, "REAL-->", strlen("REAL-->"))) {
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      *opos += strlen("REAL-->");
      clen = 0;
    } else if (!memcmp(*opos, "/*OPT", strlen("/*OPT"))) {
      next_end = next_opt = *opos + strlen("/*OPT");
      do {
        if ((blk_end = strstr(next_end, "/*END_OPT*/")) == NULL) {
          printf("can not find %s\n", "/*END_OPT*/");
          return -1;
        } else
          next_end = blk_end + strlen("/*END_OPT*/");
        if ((next_opt = strstr(next_opt, "/*OPT"))) {
          next_opt += strlen("/*OPT");
        } else
          break;
      } while (blk_end > next_opt);
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      optn = *opos + strlen("/*OPT");
      clen = 0;
      if (!memcmp("!#", optn, strlen("!#"))) {
        inverse = 1;
        optn += strlen("!#");
      } else if (!memcmp("#", optn, strlen("#"))) {
        inverse = 0;
        optn += strlen("#");
      } else {
        printf("%s has not correct format\n", "/*OPT");
        return -1;
      }
      if ((optb = strstr(optn, "*/"))) {
        *optb = '\0';
        optb += strlen("*/");
      } else {
        printf("can not find end of option name\n");
        return -1;
      }
      *opos = optb;
      if (option_match(optn, optfile) ^ inverse) {
        if (proc_tag(opos, (blk_end - *opos), npos, nlen, optfile) < 0)
          return -1;
      }
      *opos = blk_end + strlen("/*END_OPT*/");
    } else if (!memcmp(*opos, "<!--OPT", strlen("<!--OPT"))) {
      next_end = next_opt = *opos + strlen("<!--OPT");
      do {
        if ((blk_end = strstr(next_end, "<!--END_OPT-->")) == NULL) {
          printf("can not find %s\n", "<!--END_OPT-->");
          return -1;
        } else
          next_end = blk_end + strlen("<!--END_OPT-->");
        if ((next_opt = strstr(next_opt, "<!--OPT"))) {
          next_opt += strlen("<!--OPT");
        } else
          break;
      } while (blk_end > next_opt);
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      optn = *opos + strlen("<!--OPT");
      clen = 0;
      if (!memcmp("!#", optn, strlen("!#"))) {
        inverse = 1;
        optn += strlen("!#");
      } else if (!memcmp("#", optn, strlen("#"))) {
        inverse = 0;
        optn += strlen("#");
      } else {
        printf("%s has not correct format\n", "/*OPT");
        return -1;
      }
      if ((optb = strstr(optn, "-->"))) {
        *optb = '\0';
        optb += strlen("-->");
      } else {
        printf("can not find end of option name\n");
        return -1;
      }
      *opos = optb;
      if (option_match(optn, optfile) ^ inverse) {
        if (proc_tag(opos, (blk_end - *opos), npos, nlen, optfile) < 0)
          return -1;
      }
      *opos = blk_end + strlen("<!--END_OPT-->");
    } else if (!memcmp(*opos, "<!--AOPT", strlen("<!--AOPT"))) {
      memcpy(*npos, *opos - clen, clen);
      *npos += clen;
      *nlen += clen;
      clen = 0;
      optn = *opos + strlen("<!--AOPT");
      if (!memcmp("!#", optn, strlen("!#"))) {
        inverse = 1;
        optn += strlen("!#");
      } else if (!memcmp("#", optn, strlen("#"))) {
        inverse = 0;
        optn += strlen("#");
      } else {
        printf("%s has not correct format\n", "<!--AOPT");
        return -1;
      }
      if ((optb = strstr(optn, "-->"))) {
        *optb = '\0';
        optb += strlen("-->");
      } else {
        printf("can not find end of option name\n");
        return -1;
      }
      *opos = optb;
      if (!(option_match(optn, optfile) ^ inverse)) {
        printf("Do not include this page file!\n");
        return -1;
      }
    } else {
      (*opos)++;
      clen++;
    }
  }
  if (clen) {
    memcpy(*npos, *opos - clen, clen);
    *npos += clen;
    *nlen += clen;
    clen = 0;
  }
  return 0;
}


x86 assembly (clang, -O0):
<proc_tag>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmp    -0x58(%rbp),%rax
jae    2054 <proc_tag+0xee4>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
lea    0x1e36(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x70(%rbp),%rdi
mov    %eax,%edx
lea    0x1e24(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    129c <proc_tag+0x12c>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
lea    0x1e11(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    122c <proc_tag+0xbc>
lea    0x1e04(%rip),%rdi
lea    0x1df0(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,-0x78(%rbp)
lea    0x1d8e(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x78(%rbp),%rcx
cltq
add    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x50(%rbp)
jmp    204f <proc_tag+0xedf>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x80(%rbp)
lea    0x1d79(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x80(%rbp),%rdi
mov    %eax,%edx
lea    0x1d67(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1386 <proc_tag+0x216>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
lea    0x1d56(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    1310 <proc_tag+0x1a0>
lea    0x1d20(%rip),%rdi
lea    0x1d35(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,-0x88(%rbp)
lea    0x1cd0(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x88(%rbp),%rcx
cltq
add    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x50(%rbp)
jmp    204a <proc_tag+0xeda>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
lea    0x1ca1(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x90(%rbp),%rdi
mov    %eax,%edx
lea    0x1c8c(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1476 <proc_tag+0x306>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
lea    0x1c7c(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    1400 <proc_tag+0x290>
lea    0x1c30(%rip),%rdi
lea    0x1c5b(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,-0x98(%rbp)
lea    0x1bf6(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x98(%rbp),%rcx
cltq
add    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x50(%rbp)
jmp    2045 <proc_tag+0xed5>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xa0(%rbp)
lea    0x1bcd(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xa0(%rbp),%rdi
mov    %eax,%edx
lea    0x1bb8(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1518 <proc_tag+0x3a8>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
lea    0x1b63(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
movl   $0x0,-0x50(%rbp)
jmp    2040 <proc_tag+0xed0>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xa8(%rbp)
lea    0x1b32(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xa8(%rbp),%rdi
mov    %eax,%edx
lea    0x1b1d(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    15ba <proc_tag+0x44a>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
lea    0x1ac8(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
movl   $0x0,-0x50(%rbp)
jmp    203b <proc_tag+0xecb>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xb0(%rbp)
lea    0x1a97(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xb0(%rbp),%rdi
mov    %eax,%edx
lea    0x1a82(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    165c <proc_tag+0x4ec>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
lea    0x1a2d(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
movl   $0x0,-0x50(%rbp)
jmp    2036 <proc_tag+0xec6>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xb8(%rbp)
lea    0x19fe(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xb8(%rbp),%rdi
mov    %eax,%edx
lea    0x19e9(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    16fe <proc_tag+0x58e>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
lea    0x1994(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
movl   $0x0,-0x50(%rbp)
jmp    2031 <proc_tag+0xec1>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xc0(%rbp)
lea    0x1964(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xc0(%rbp),%rdi
mov    %eax,%edx
lea    0x194f(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1a6d <proc_tag+0x8fd>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xc8(%rbp)
lea    0x192c(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0xc8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
lea    0x190b(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    17a6 <proc_tag+0x636>
lea    0x188a(%rip),%rdi
lea    0x18ea(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
mov    -0x38(%rbp),%rax
mov    %rax,-0xd0(%rbp)
lea    0x18c5(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0xd0(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rdi
lea    0x189c(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
je     180f <proc_tag+0x69f>
lea    0x1882(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
jmp    1814 <proc_tag+0x6a4>
jmp    1827 <proc_tag+0x6b7>
jmp    1819 <proc_tag+0x6a9>
mov    -0x38(%rbp),%rax
cmp    -0x68(%rbp),%rax
ja     1767 <proc_tag+0x5f7>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xe0(%rbp)
lea    0x17fb(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0xe0(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0xd8(%rbp)
lea    0x17dc(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xd8(%rbp),%rsi
mov    %eax,%edx
lea    0x17c7(%rip),%rdi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    18f8 <proc_tag+0x788>
movl   $0x1,-0x4c(%rbp)
lea    0x17ab(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    197b <proc_tag+0x80b>
mov    -0x40(%rbp),%rax
mov    %rax,-0xe8(%rbp)
lea    0x1780(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xe8(%rbp),%rsi
mov    %eax,%edx
lea    0x176b(%rip),%rdi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1955 <proc_tag+0x7e5>
movl   $0x0,-0x4c(%rbp)
lea    0x174f(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1976 <proc_tag+0x806>
lea    0x1730(%rip),%rdi
lea    0x1714(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
jmp    197b <proc_tag+0x80b>
mov    -0x40(%rbp),%rdi
lea    0x16dd(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
je     19c1 <proc_tag+0x851>
mov    -0x48(%rbp),%rax
movb   $0x0,(%rax)
lea    0x16bc(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    19db <proc_tag+0x86b>
lea    0x16df(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
mov    -0x48(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1080 <option_match@plt>
xor    -0x4c(%rbp),%eax
cmp    $0x0,%eax
je     1a3e <proc_tag+0x8ce>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    %eax,%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
call   1070 <proc_tag@plt>
cmp    $0x0,%eax
jge    1a39 <proc_tag+0x8c9>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
jmp    1a3e <proc_tag+0x8ce>
mov    -0x38(%rbp),%rax
mov    %rax,-0xf0(%rbp)
lea    0x162d(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xf0(%rbp),%rcx
cltq
add    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
jmp    202c <proc_tag+0xebc>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xf8(%rbp)
lea    0x1646(%rip),%rdi
call   1030 <strlen@plt>
mov    -0xf8(%rbp),%rdi
mov    %eax,%edx
lea    0x1631(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1ddc <proc_tag+0xc6c>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x100(%rbp)
lea    0x160e(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x100(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
lea    0x15ef(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    1b15 <proc_tag+0x9a5>
lea    0x151b(%rip),%rdi
lea    0x15ce(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
mov    -0x38(%rbp),%rax
mov    %rax,-0x108(%rbp)
lea    0x15a9(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x108(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rdi
lea    0x157e(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
je     1b7e <proc_tag+0xa0e>
lea    0x1564(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
jmp    1b83 <proc_tag+0xa13>
jmp    1b96 <proc_tag+0xa26>
jmp    1b88 <proc_tag+0xa18>
mov    -0x38(%rbp),%rax
cmp    -0x68(%rbp),%rax
ja     1ad6 <proc_tag+0x966>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x118(%rbp)
lea    0x14dd(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x118(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x110(%rbp)
lea    0x146d(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x110(%rbp),%rsi
mov    %eax,%edx
lea    0x1458(%rip),%rdi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1c67 <proc_tag+0xaf7>
movl   $0x1,-0x4c(%rbp)
lea    0x143c(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1cea <proc_tag+0xb7a>
mov    -0x40(%rbp),%rax
mov    %rax,-0x120(%rbp)
lea    0x1411(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x120(%rbp),%rsi
mov    %eax,%edx
lea    0x13fc(%rip),%rdi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1cc4 <proc_tag+0xb54>
movl   $0x0,-0x4c(%rbp)
lea    0x13e0(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1ce5 <proc_tag+0xb75>
lea    0x13c1(%rip),%rdi
lea    0x13a5(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
jmp    1cea <proc_tag+0xb7a>
mov    -0x40(%rbp),%rdi
lea    0x1343(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
je     1d30 <proc_tag+0xbc0>
mov    -0x48(%rbp),%rax
movb   $0x0,(%rax)
lea    0x1322(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1d4a <proc_tag+0xbda>
lea    0x1370(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
mov    -0x48(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1080 <option_match@plt>
xor    -0x4c(%rbp),%eax
cmp    $0x0,%eax
je     1dad <proc_tag+0xc3d>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    %eax,%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
call   1070 <proc_tag@plt>
cmp    $0x0,%eax
jge    1da8 <proc_tag+0xc38>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
jmp    1dad <proc_tag+0xc3d>
mov    -0x38(%rbp),%rax
mov    %rax,-0x128(%rbp)
lea    0x1311(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x128(%rbp),%rcx
cltq
add    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
jmp    2027 <proc_tag+0xeb7>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x130(%rbp)
lea    0x12ee(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x130(%rbp),%rdi
mov    %eax,%edx
lea    0x12d9(%rip),%rsi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    200b <proc_tag+0xe9b>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
movl   $0x0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x140(%rbp)
lea    0x126f(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x140(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x138(%rbp)
lea    0x11ef(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x138(%rbp),%rsi
mov    %eax,%edx
lea    0x11da(%rip),%rdi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1ee5 <proc_tag+0xd75>
movl   $0x1,-0x4c(%rbp)
lea    0x11be(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1f68 <proc_tag+0xdf8>
mov    -0x40(%rbp),%rax
mov    %rax,-0x148(%rbp)
lea    0x1193(%rip),%rdi
call   1030 <strlen@plt>
mov    -0x148(%rbp),%rsi
mov    %eax,%edx
lea    0x117e(%rip),%rdi
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1f42 <proc_tag+0xdd2>
movl   $0x0,-0x4c(%rbp)
lea    0x1162(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1f63 <proc_tag+0xdf3>
lea    0x1143(%rip),%rdi
lea    0x118f(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
jmp    1f68 <proc_tag+0xdf8>
mov    -0x40(%rbp),%rdi
lea    0x10c5(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
je     1fae <proc_tag+0xe3e>
mov    -0x48(%rbp),%rax
movb   $0x0,(%rax)
lea    0x10a4(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1fc8 <proc_tag+0xe58>
lea    0x10f2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
mov    -0x48(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1080 <option_match@plt>
xor    -0x4c(%rbp),%eax
cmp    $0x0,%eax
jne    2006 <proc_tag+0xe96>
lea    0x10f5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    20ac <proc_tag+0xf3c>
jmp    2022 <proc_tag+0xeb2>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2027 <proc_tag+0xeb7>
jmp    202c <proc_tag+0xebc>
jmp    2031 <proc_tag+0xec1>
jmp    2036 <proc_tag+0xec6>
jmp    203b <proc_tag+0xecb>
jmp    2040 <proc_tag+0xed0>
jmp    2045 <proc_tag+0xed5>
jmp    204a <proc_tag+0xeda>
jmp    204f <proc_tag+0xedf>
jmp    11a7 <proc_tag+0x37>
cmpl   $0x0,-0x50(%rbp)
je     20a5 <proc_tag+0xf35>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
movslq -0x50(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<proc_tag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,0x8(%rsp)
mov    %rdi,(%rsp)
test   %esi,%esi
jle    1985 <proc_tag+0x805>
mov    %rcx,%r14
mov    %r8,0x18(%rsp)
mov    (%rsp),%rax
mov    (%rax),%r15
movslq %esi,%rax
add    %r15,%rax
mov    %rax,0x20(%rsp)
xor    %r12d,%r12d
lea    0xe46(%rip),%r13
mov    %rcx,0x10(%rsp)
nopl   0x0(%rax,%rax,1)
lea    0xe29(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
mov    (%rsp),%rcx
mov    (%rcx),%rbx
test   %eax,%eax
je     13b0 <proc_tag+0x230>
lea    0xe25(%rip),%rbp
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
mov    (%rsp),%rcx
mov    (%rcx),%rbx
test   %eax,%eax
je     1400 <proc_tag+0x280>
lea    0xe0f(%rip),%rbp
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
mov    (%rsp),%rcx
mov    (%rcx),%rbx
test   %eax,%eax
je     14a1 <proc_tag+0x321>
lea    0xe00(%rip),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
test   %eax,%eax
je     1460 <proc_tag+0x2e0>
mov    (%rsp),%rax
mov    (%rax),%rbx
lea    0xddc(%rip),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
test   %eax,%eax
je     1460 <proc_tag+0x2e0>
mov    (%rsp),%rax
mov    (%rax),%rbx
lea    0xdb8(%rip),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
test   %eax,%eax
je     1460 <proc_tag+0x2e0>
mov    (%rsp),%rax
mov    (%rax),%rbx
lea    0xd96(%rip),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
test   %eax,%eax
je     1460 <proc_tag+0x2e0>
mov    (%rsp),%rbx
mov    (%rbx),%r14
lea    0xd73(%rip),%rbp
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
mov    (%rbx),%r13
test   %eax,%eax
je     150f <proc_tag+0x38f>
lea    0xd7c(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
mov    (%rsp),%rcx
mov    (%rcx),%rbp
test   %eax,%eax
je     1615 <proc_tag+0x495>
lea    0xd68(%rip),%r15
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
test   %eax,%eax
je     171b <proc_tag+0x59b>
mov    (%rsp),%rax
mov    (%rax),%r15
add    $0x1,%r15
mov    %r15,(%rax)
add    $0x1,%r12d
mov    0x10(%rsp),%r14
lea    0xc78(%rip),%r13
cmp    0x20(%rsp),%r15
jb     11d0 <proc_tag+0x50>
jmp    1955 <proc_tag+0x7d5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r13,%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     1989 <proc_tag+0x809>
mov    %rax,%r15
mov    0x8(%rsp),%r13
mov    0x0(%r13),%rdi
movslq %r12d,%rbp
sub    %rbp,%rbx
mov    %rbx,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
add    %rbp,0x0(%r13)
lea    0xc1d(%rip),%r13
add    %r12d,(%r14)
mov    %r13,%rdi
jmp    14eb <proc_tag+0x36b>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
lea    0xc28(%rip),%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     1999 <proc_tag+0x819>
mov    %rax,%r15
mov    0x8(%rsp),%r13
mov    0x0(%r13),%rdi
movslq %r12d,%rbp
sub    %rbp,%rbx
mov    %rbx,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
add    %rbp,0x0(%r13)
lea    0xbc9(%rip),%r13
add    %r12d,(%r14)
lea    0xbe8(%rip),%rdi
mov    (%rsp),%rbx
call   1040 <strlen@plt>
cltq
add    %rax,%r15
mov    %r15,(%rbx)
jmp    14fc <proc_tag+0x37c>
mov    0x8(%rsp),%r15
mov    (%r15),%rdi
mov    (%rsp),%rbp
mov    0x0(%rbp),%rsi
movslq %r12d,%rbx
sub    %rbx,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
add    %rbx,(%r15)
mov    0x10(%rsp),%rax
add    %r12d,(%rax)
mov    %r14,%rdi
mov    %rax,%r14
call   1040 <strlen@plt>
movslq %eax,%r15
add    0x0(%rbp),%r15
mov    %r15,0x0(%rbp)
jmp    14fc <proc_tag+0x37c>
mov    %rbx,%rdi
lea    0xb9d(%rip),%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     19b9 <proc_tag+0x839>
mov    %rax,%r15
mov    0x8(%rsp),%r13
mov    0x0(%r13),%rdi
movslq %r12d,%rbp
sub    %rbp,%rbx
mov    %rbx,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
add    %rbp,0x0(%r13)
lea    0xb28(%rip),%r13
add    %r12d,(%r14)
lea    0xb5d(%rip),%rdi
call   1040 <strlen@plt>
cltq
add    %rax,%r15
mov    (%rsp),%rax
mov    %r15,(%rax)
xor    %r12d,%r12d
cmp    0x20(%rsp),%r15
jb     11d0 <proc_tag+0x50>
jmp    1955 <proc_tag+0x7d5>
mov    %rbp,%rdi
call   1040 <strlen@plt>
cltq
add    %rax,%r13
mov    %r13,%rbx
nop
mov    %r13,%rdi
lea    0xb53(%rip),%rbp
mov    %rbp,%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     19a9 <proc_tag+0x829>
mov    %rax,%r15
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
lea    0xb25(%rip),%r14
mov    %r14,%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     157a <proc_tag+0x3fa>
mov    %rax,%rbx
movslq %ebp,%r13
add    %r15,%r13
mov    %r14,%rdi
call   1040 <strlen@plt>
cltq
add    %rax,%rbx
cmp    %rbx,%r15
ja     1520 <proc_tag+0x3a0>
mov    0x8(%rsp),%rbp
mov    0x0(%rbp),%rdi
mov    (%rsp),%r13
mov    0x0(%r13),%rsi
movslq %r12d,%rbx
sub    %rbx,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
add    %rbx,0x0(%rbp)
mov    0x10(%rsp),%rax
add    %r12d,(%rax)
mov    0x0(%r13),%rbx
mov    %r14,%rdi
call   1040 <strlen@plt>
movslq %eax,%rbp
add    %rbx,%rbp
lea    0xacb(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
test   %eax,%eax
je     17a6 <proc_tag+0x626>
lea    0xaa8(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
xor    %r12d,%r12d
test   %eax,%eax
lea    0xa06(%rip),%r13
lea    0xa59(%rip),%r14
je     17ba <proc_tag+0x63a>
jmp    19fd <proc_tag+0x87d>
mov    %rbx,%rdi
call   1040 <strlen@plt>
cltq
add    %rax,%rbp
mov    %rbp,%rbx
mov    0x10(%rsp),%r14
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rdi
lea    0xa75(%rip),%rbp
mov    %rbp,%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     19c9 <proc_tag+0x849>
mov    %rax,%r15
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
lea    0xa45(%rip),%r13
mov    %r13,%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     168a <proc_tag+0x50a>
mov    %rax,%rbx
movslq %ebp,%rbp
add    %r15,%rbp
mov    %r13,%rdi
call   1040 <strlen@plt>
cltq
add    %rax,%rbx
cmp    %rbx,%r15
ja     1630 <proc_tag+0x4b0>
mov    0x8(%rsp),%rbp
mov    0x0(%rbp),%rdi
mov    (%rsp),%rax
mov    (%rax),%rsi
movslq %r12d,%rbx
sub    %rbx,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
add    %rbx,0x0(%rbp)
add    %r12d,(%r14)
mov    (%rsp),%rax
mov    (%rax),%rbx
mov    %r13,%rdi
call   1040 <strlen@plt>
movslq %eax,%rbp
add    %rbx,%rbp
lea    0x9be(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
test   %eax,%eax
je     183e <proc_tag+0x6be>
lea    0x99b(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
xor    %r12d,%r12d
test   %eax,%eax
lea    0x8f9(%rip),%r13
je     184b <proc_tag+0x6cb>
jmp    19fd <proc_tag+0x87d>
mov    0x8(%rsp),%rbp
mov    0x0(%rbp),%rdi
mov    (%rsp),%r14
mov    (%r14),%rsi
movslq %r12d,%rbx
sub    %rbx,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
add    %rbx,0x0(%rbp)
mov    0x10(%rsp),%rax
add    %r12d,(%rax)
mov    (%r14),%rbx
mov    %r15,%rdi
call   1040 <strlen@plt>
movslq %eax,%rbp
add    %rbx,%rbp
lea    0x92c(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
test   %eax,%eax
je     18d6 <proc_tag+0x756>
lea    0x909(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <memcmp@plt>
xor    %r15d,%r15d
test   %eax,%eax
je     18dc <proc_tag+0x75c>
jmp    1a1b <proc_tag+0x89b>
mov    $0x1,%r12d
lea    0x856(%rip),%r13
lea    0x8a9(%rip),%r14
mov    %rbx,%rdi
call   1040 <strlen@plt>
cltq
add    %rax,%rbp
mov    %rbp,%rdi
mov    %r14,%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     19f4 <proc_tag+0x874>
mov    %rax,%rbx
movb   $0x0,(%rax)
mov    %r14,%rdi
call   1040 <strlen@plt>
cltq
add    %rbx,%rax
mov    (%rsp),%rcx
mov    %rax,(%rcx)
mov    %rbp,%rdi
mov    0x18(%rsp),%rbx
mov    %rbx,%rsi
call   1090 <option_match@plt>
cmp    %r12d,%eax
mov    0x10(%rsp),%r14
je     1832 <proc_tag+0x6b2>
mov    (%rsp),%rdi
mov    (%rdi),%eax
mov    %r15d,%esi
sub    %eax,%esi
mov    0x8(%rsp),%rdx
mov    %r14,%rcx
mov    %rbx,%r8
call   1080 <proc_tag@plt>
test   %eax,%eax
js     19de <proc_tag+0x85e>
lea    0x844(%rip),%rdi
jmp    14eb <proc_tag+0x36b>
mov    $0x1,%r12d
lea    0x7be(%rip),%r13
mov    %rbx,%rdi
call   1040 <strlen@plt>
cltq
add    %rax,%rbp
mov    %rbp,%rdi
lea    0x7d6(%rip),%r14
mov    %r14,%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     19f4 <proc_tag+0x874>
mov    %rax,%rbx
movb   $0x0,(%rax)
mov    %r14,%rdi
call   1040 <strlen@plt>
cltq
add    %rbx,%rax
mov    (%rsp),%rcx
mov    %rax,(%rcx)
mov    %rbp,%rdi
mov    0x18(%rsp),%rbx
mov    %rbx,%rsi
call   1090 <option_match@plt>
cmp    %r12d,%eax
mov    0x10(%rsp),%r14
je     18ca <proc_tag+0x74a>
mov    (%rsp),%rdi
mov    (%rdi),%eax
mov    %r15d,%esi
sub    %eax,%esi
mov    0x8(%rsp),%rdx
mov    %r14,%rcx
mov    %rbx,%r8
call   1080 <proc_tag@plt>
test   %eax,%eax
js     19de <proc_tag+0x85e>
lea    0x7de(%rip),%rdi
jmp    14eb <proc_tag+0x36b>
mov    $0x1,%r15d
mov    %rbx,%rdi
call   1040 <strlen@plt>
cltq
add    %rax,%rbp
mov    %rbp,%rdi
lea    0x745(%rip),%r14
mov    %r14,%rsi
call   10a0 <strstr@plt>
test   %rax,%rax
je     19f4 <proc_tag+0x874>
mov    %rax,%rbx
movb   $0x0,(%rax)
mov    %r14,%rdi
call   1040 <strlen@plt>
cltq
add    %rbx,%rax
mov    (%rsp),%rcx
mov    %rax,(%rcx)
mov    %rbp,%rdi
mov    0x18(%rsp),%rsi
call   1090 <option_match@plt>
cmp    %r15d,%eax
je     1a0d <proc_tag+0x88d>
mov    (%rsp),%rax
mov    (%rax),%r15
xor    %r12d,%r12d
lea    0x6c4(%rip),%r13
mov    0x10(%rsp),%r14
cmp    0x20(%rsp),%r15
jb     11d0 <proc_tag+0x50>
xor    %ebx,%ebx
test   %r12d,%r12d
je     19e3 <proc_tag+0x863>
mov    %r14,%r13
mov    0x8(%rsp),%r14
mov    (%r14),%rdi
movslq %r12d,%rbp
sub    %rbp,%r15
mov    %r15,%rsi
mov    %r12d,%edx
call   1070 <memcpy@plt>
add    %rbp,(%r14)
add    %r12d,0x0(%r13)
jmp    19e3 <proc_tag+0x863>
xor    %ebx,%ebx
jmp    19e3 <proc_tag+0x863>
lea    0x686(%rip),%rdi
lea    0x672(%rip),%rsi
jmp    19d7 <proc_tag+0x857>
lea    0x676(%rip),%rdi
lea    0x68b(%rip),%rsi
jmp    19d7 <proc_tag+0x857>
lea    0x666(%rip),%rdi
lea    0x6c6(%rip),%rsi
jmp    19d7 <proc_tag+0x857>
lea    0x656(%rip),%rdi
lea    0x681(%rip),%rsi
jmp    19d7 <proc_tag+0x857>
lea    0x646(%rip),%rdi
lea    0x6d8(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xffffffff,%ebx
mov    %ebx,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x6cc(%rip),%rdi
jmp    1a14 <proc_tag+0x894>
lea    0x688(%rip),%rdi
lea    0x66c(%rip),%rsi
jmp    19d7 <proc_tag+0x857>
lea    0x6d3(%rip),%rdi
call   1030 <puts@plt>
jmp    19de <proc_tag+0x85e>
lea    0x66a(%rip),%rdi
lea    0x695(%rip),%rsi
jmp    19d7 <proc_tag+0x857>

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

LLVM IR (-O2):
@.str = [9 x i8] c"/*DEMO*/\00"
@.str.1 = [13 x i8] c"/*END_DEMO*/\00"
@.str.2 = [17 x i8] c"can not find %s\0A\00"
@.str.3 = [11 x i8] c"<!--DO_CGI\00"
@.str.4 = [10 x i8] c"DO_CGI-->\00"
@.str.5 = [12 x i8] c"<!--DEMO-->\00"
@.str.6 = [16 x i8] c"<!--END_DEMO-->\00"
@.str.7 = [7 x i8] c"/*REAL\00"
@.str.8 = [7 x i8] c"REAL*/\00"
@.str.9 = [9 x i8] c"<!--REAL\00"
@.str.10 = [8 x i8] c"REAL-->\00"
@.str.11 = [6 x i8] c"/*OPT\00"
@.str.12 = [12 x i8] c"/*END_OPT*/\00"
@.str.13 = [3 x i8] c"!#\00"
@.str.14 = [2 x i8] c"#\00"
@.str.15 = [27 x i8] c"%s has not correct format\0A\00"
@.str.16 = [3 x i8] c"*/\00"
@.str.18 = [8 x i8] c"<!--OPT\00"
@.str.19 = [15 x i8] c"<!--END_OPT-->\00"
@.str.20 = [4 x i8] c"-->\00"
@.str.21 = [9 x i8] c"<!--AOPT\00"
@str.24 = [32 x i8] c"can not find end of option name\00"
@str.25 = [31 x i8] c"Do not include this page file!\00"
define i32 @proc_tag(i8** %0, i32 %1, i8** %2, i32* %3, i8* %4) {
%6 = load i8*, i8** %0
%7 = sext i32 %1 to i64
%8 = getelementptr inbounds i8, i8* %6, i64 %7
%9 = icmp sgt i32 %1, 0
br i1 %9, label %10, label %387
10: ; preds = %5, %371
%11 = phi i8* [ %372, %371 ], [ %6, %5 ]
%12 = phi i32 [ %373, %371 ], [ 0, %5 ]
%13 = tail call i32 @strlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%14 = tail call i32 @memcmp(i8* %11, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i32 %13)
%15 = icmp eq i32 %14, 0
%16 = load i8*, i8** %0
br i1 %15, label %17, label %35
17: ; preds = %10
%18 = tail call i8* @strstr(i8* dereferenceable(1) %16, i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
%19 = icmp eq i8* %18, null
br i1 %19, label %20, label %22
20: ; preds = %17
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
br label %387
22: ; preds = %17
%23 = load i8*, i8** %2
%24 = sext i32 %12 to i64
%25 = sub nsw i64 0, %24
%26 = getelementptr inbounds i8, i8* %16, i64 %25
%27 = tail call i32 @memcpy(i8* %23, i8* %26, i32 %12)
%28 = load i8*, i8** %2
%29 = getelementptr inbounds i8, i8* %28, i64 %24
store i8* %29, i8** %2
%30 = load i32, i32* %3
%31 = add nsw i32 %30, %12
store i32 %31, i32* %3
%32 = tail call i32 @strlen(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %18, i64 %33
store i8* %34, i8** %0
br label %371
35: ; preds = %10
%36 = tail call i32 @strlen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
%37 = tail call i32 @memcmp(i8* %16, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i32 %36)
%38 = icmp eq i32 %37, 0
%39 = load i8*, i8** %0
br i1 %38, label %40, label %58
40: ; preds = %35
%41 = tail call i8* @strstr(i8* dereferenceable(1) %39, i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0))
%42 = icmp eq i8* %41, null
br i1 %42, label %43, label %45
43: ; preds = %40
%44 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0))
br label %387
45: ; preds = %40
%46 = load i8*, i8** %2
%47 = sext i32 %12 to i64
%48 = sub nsw i64 0, %47
%49 = getelementptr inbounds i8, i8* %39, i64 %48
%50 = tail call i32 @memcpy(i8* %46, i8* %49, i32 %12)
%51 = load i8*, i8** %2
%52 = getelementptr inbounds i8, i8* %51, i64 %47
store i8* %52, i8** %2
%53 = load i32, i32* %3
%54 = add nsw i32 %53, %12
store i32 %54, i32* %3
%55 = tail call i32 @strlen(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0))
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %41, i64 %56
store i8* %57, i8** %0
br label %371
58: ; preds = %35
%59 = tail call i32 @strlen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0))
%60 = tail call i32 @memcmp(i8* %39, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0), i32 %59)
%61 = icmp eq i32 %60, 0
%62 = load i8*, i8** %0
br i1 %61, label %63, label %81
63: ; preds = %58
%64 = tail call i8* @strstr(i8* dereferenceable(1) %62, i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.6, i64 0, i64 0))
%65 = icmp eq i8* %64, null
br i1 %65, label %66, label %68
66: ; preds = %63
%67 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.6, i64 0, i64 0))
br label %387
68: ; preds = %63
%69 = load i8*, i8** %2
%70 = sext i32 %12 to i64
%71 = sub nsw i64 0, %70
%72 = getelementptr inbounds i8, i8* %62, i64 %71
%73 = tail call i32 @memcpy(i8* %69, i8* %72, i32 %12)
%74 = load i8*, i8** %2
%75 = getelementptr inbounds i8, i8* %74, i64 %70
store i8* %75, i8** %2
%76 = load i32, i32* %3
%77 = add nsw i32 %76, %12
store i32 %77, i32* %3
%78 = tail call i32 @strlen(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.6, i64 0, i64 0))
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i8, i8* %64, i64 %79
store i8* %80, i8** %0
br label %371
81: ; preds = %58
%82 = tail call i32 @strlen(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
%83 = tail call i32 @memcmp(i8* %62, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %82)
%84 = icmp eq i32 %83, 0
br i1 %84, label %85, label %100
85: ; preds = %81
%86 = load i8*, i8** %2
%87 = load i8*, i8** %0
%88 = sext i32 %12 to i64
%89 = sub nsw i64 0, %88
%90 = getelementptr inbounds i8, i8* %87, i64 %89
%91 = tail call i32 @memcpy(i8* %86, i8* %90, i32 %12)
%92 = load i8*, i8** %2
%93 = getelementptr inbounds i8, i8* %92, i64 %88
store i8* %93, i8** %2
%94 = load i32, i32* %3
%95 = add nsw i32 %94, %12
store i32 %95, i32* %3
%96 = tail call i32 @strlen(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
%97 = load i8*, i8** %0
%98 = sext i32 %96 to i64
%99 = getelementptr inbounds i8, i8* %97, i64 %98
store i8* %99, i8** %0
br label %371
100: ; preds = %81
%101 = load i8*, i8** %0
%102 = tail call i32 @strlen(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0))
%103 = tail call i32 @memcmp(i8* %101, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i32 %102)
%104 = icmp eq i32 %103, 0
br i1 %104, label %105, label %120
105: ; preds = %100
%106 = load i8*, i8** %2
%107 = load i8*, i8** %0
%108 = sext i32 %12 to i64
%109 = sub nsw i64 0, %108
%110 = getelementptr inbounds i8, i8* %107, i64 %109
%111 = tail call i32 @memcpy(i8* %106, i8* %110, i32 %12)
%112 = load i8*, i8** %2
%113 = getelementptr inbounds i8, i8* %112, i64 %108
store i8* %113, i8** %2
%114 = load i32, i32* %3
%115 = add nsw i32 %114, %12
store i32 %115, i32* %3
%116 = tail call i32 @strlen(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0))
%117 = load i8*, i8** %0
%118 = sext i32 %116 to i64
%119 = getelementptr inbounds i8, i8* %117, i64 %118
store i8* %119, i8** %0
br label %371
120: ; preds = %100
%121 = load i8*, i8** %0
%122 = tail call i32 @strlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i64 0, i64 0))
%123 = tail call i32 @memcmp(i8* %121, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i64 0, i64 0), i32 %122)
%124 = icmp eq i32 %123, 0
br i1 %124, label %125, label %140
125: ; preds = %120
%126 = load i8*, i8** %2
%127 = load i8*, i8** %0
%128 = sext i32 %12 to i64
%129 = sub nsw i64 0, %128
%130 = getelementptr inbounds i8, i8* %127, i64 %129
%131 = tail call i32 @memcpy(i8* %126, i8* %130, i32 %12)
%132 = load i8*, i8** %2
%133 = getelementptr inbounds i8, i8* %132, i64 %128
store i8* %133, i8** %2
%134 = load i32, i32* %3
%135 = add nsw i32 %134, %12
store i32 %135, i32* %3
%136 = tail call i32 @strlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i64 0, i64 0))
%137 = load i8*, i8** %0
%138 = sext i32 %136 to i64
%139 = getelementptr inbounds i8, i8* %137, i64 %138
store i8* %139, i8** %0
br label %371
140: ; preds = %120
%141 = load i8*, i8** %0
%142 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0))
%143 = tail call i32 @memcmp(i8* %141, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0), i32 %142)
%144 = icmp eq i32 %143, 0
br i1 %144, label %145, label %160
145: ; preds = %140
%146 = load i8*, i8** %2
%147 = load i8*, i8** %0
%148 = sext i32 %12 to i64
%149 = sub nsw i64 0, %148
%150 = getelementptr inbounds i8, i8* %147, i64 %149
%151 = tail call i32 @memcpy(i8* %146, i8* %150, i32 %12)
%152 = load i8*, i8** %2
%153 = getelementptr inbounds i8, i8* %152, i64 %148
store i8* %153, i8** %2
%154 = load i32, i32* %3
%155 = add nsw i32 %154, %12
store i32 %155, i32* %3
%156 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0))
%157 = load i8*, i8** %0
%158 = sext i32 %156 to i64
%159 = getelementptr inbounds i8, i8* %157, i64 %158
store i8* %159, i8** %0
br label %371
160: ; preds = %140
%161 = load i8*, i8** %0
%162 = tail call i32 @strlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
%163 = tail call i32 @memcmp(i8* %161, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0), i32 %162)
%164 = icmp eq i32 %163, 0
%165 = load i8*, i8** %0
br i1 %164, label %166, label %240
166: ; preds = %160
%167 = tail call i32 @strlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds i8, i8* %165, i64 %168
br label %170
170: ; preds = %181, %166
%171 = phi i8* [ %169, %166 ], [ %183, %181 ]
%172 = phi i8* [ %169, %166 ], [ %186, %181 ]
%173 = tail call i8* @strstr(i8* dereferenceable(1) %171, i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.12, i64 0, i64 0))
%174 = icmp eq i8* %173, null
br i1 %174, label %175, label %177
175: ; preds = %170
%176 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.12, i64 0, i64 0))
br label %387
177: ; preds = %170
%178 = tail call i32 @strlen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.12, i64 0, i64 0))
%179 = tail call i8* @strstr(i8* dereferenceable(1) %172, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
%180 = icmp eq i8* %179, null
br i1 %180, label %188, label %181
181: ; preds = %177
%182 = sext i32 %178 to i64
%183 = getelementptr inbounds i8, i8* %173, i64 %182
%184 = tail call i32 @strlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i8, i8* %179, i64 %185
%187 = icmp ugt i8* %173, %186
br i1 %187, label %170, label %188
188: ; preds = %177, %181
%189 = load i8*, i8** %2
%190 = load i8*, i8** %0
%191 = sext i32 %12 to i64
%192 = sub nsw i64 0, %191
%193 = getelementptr inbounds i8, i8* %190, i64 %192
%194 = tail call i32 @memcpy(i8* %189, i8* %193, i32 %12)
%195 = load i8*, i8** %2
%196 = getelementptr inbounds i8, i8* %195, i64 %191
store i8* %196, i8** %2
%197 = load i32, i32* %3
%198 = add nsw i32 %197, %12
store i32 %198, i32* %3
%199 = load i8*, i8** %0
%200 = tail call i32 @strlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i8, i8* %199, i64 %201
%203 = tail call i32 @strlen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%204 = tail call i32 @memcmp(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* %202, i32 %203)
%205 = icmp eq i32 %204, 0
br i1 %205, label %212, label %206
206: ; preds = %188
%207 = tail call i32 @strlen(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
%208 = tail call i32 @memcmp(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), i8* %202, i32 %207)
%209 = icmp eq i32 %208, 0
br i1 %209, label %212, label %210
210: ; preds = %206
%211 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
br label %387
212: ; preds = %206, %188
%213 = phi i8* [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), %188 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), %206 ]
%214 = phi i32 [ 1, %188 ], [ 0, %206 ]
%215 = tail call i32 @strlen(i8* %213)
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i8, i8* %202, i64 %216
%218 = tail call i8* @strstr(i8* dereferenceable(1) %217, i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%219 = icmp eq i8* %218, null
br i1 %219, label %226, label %220
220: ; preds = %212
store i8 0, i8* %218
%221 = tail call i32 @strlen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i8, i8* %218, i64 %222
store i8* %223, i8** %0
%224 = tail call i32 @option_match(i8* %217, i8* %4)
%225 = icmp eq i32 %224, %214
br i1 %225, label %236, label %228
226: ; preds = %212
%227 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.24, i64 0, i64 0))
br label %387
228: ; preds = %220
%229 = load i8*, i8** %0
%230 = ptrtoint i8* %173 to i64
%231 = ptrtoint i8* %229 to i64
%232 = sub i64 %230, %231
%233 = trunc i64 %232 to i32
%234 = tail call i32 @proc_tag(i8** %0, i32 %233, i8** %2, i32* %3, i8* %4)
%235 = icmp slt i32 %234, 0
br i1 %235, label %387, label %236
236: ; preds = %228, %220
%237 = tail call i32 @strlen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.12, i64 0, i64 0))
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i8, i8* %173, i64 %238
store i8* %239, i8** %0
br label %371
240: ; preds = %160
%241 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0))
%242 = tail call i32 @memcmp(i8* %165, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0), i32 %241)
%243 = icmp eq i32 %242, 0
%244 = load i8*, i8** %0
br i1 %243, label %245, label %319
245: ; preds = %240
%246 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0))
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds i8, i8* %244, i64 %247
br label %249
249: ; preds = %260, %245
%250 = phi i8* [ %248, %245 ], [ %262, %260 ]
%251 = phi i8* [ %248, %245 ], [ %265, %260 ]
%252 = tail call i8* @strstr(i8* dereferenceable(1) %250, i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.19, i64 0, i64 0))
%253 = icmp eq i8* %252, null
br i1 %253, label %254, label %256
254: ; preds = %249
%255 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.19, i64 0, i64 0))
br label %387
256: ; preds = %249
%257 = tail call i32 @strlen(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.19, i64 0, i64 0))
%258 = tail call i8* @strstr(i8* dereferenceable(1) %251, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0))
%259 = icmp eq i8* %258, null
br i1 %259, label %267, label %260
260: ; preds = %256
%261 = sext i32 %257 to i64
%262 = getelementptr inbounds i8, i8* %252, i64 %261
%263 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0))
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %258, i64 %264
%266 = icmp ugt i8* %252, %265
br i1 %266, label %249, label %267
267: ; preds = %256, %260
%268 = load i8*, i8** %2
%269 = load i8*, i8** %0
%270 = sext i32 %12 to i64
%271 = sub nsw i64 0, %270
%272 = getelementptr inbounds i8, i8* %269, i64 %271
%273 = tail call i32 @memcpy(i8* %268, i8* %272, i32 %12)
%274 = load i8*, i8** %2
%275 = getelementptr inbounds i8, i8* %274, i64 %270
store i8* %275, i8** %2
%276 = load i32, i32* %3
%277 = add nsw i32 %276, %12
store i32 %277, i32* %3
%278 = load i8*, i8** %0
%279 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0))
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i8, i8* %278, i64 %280
%282 = tail call i32 @strlen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%283 = tail call i32 @memcmp(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* %281, i32 %282)
%284 = icmp eq i32 %283, 0
br i1 %284, label %291, label %285
285: ; preds = %267
%286 = tail call i32 @strlen(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
%287 = tail call i32 @memcmp(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), i8* %281, i32 %286)
%288 = icmp eq i32 %287, 0
br i1 %288, label %291, label %289
289: ; preds = %285
%290 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
br label %387
291: ; preds = %285, %267
%292 = phi i8* [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), %267 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), %285 ]
%293 = phi i32 [ 1, %267 ], [ 0, %285 ]
%294 = tail call i32 @strlen(i8* %292)
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i8, i8* %281, i64 %295
%297 = tail call i8* @strstr(i8* dereferenceable(1) %296, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0))
%298 = icmp eq i8* %297, null
br i1 %298, label %305, label %299
299: ; preds = %291
store i8 0, i8* %297
%300 = tail call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0))
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i8, i8* %297, i64 %301
store i8* %302, i8** %0
%303 = tail call i32 @option_match(i8* %296, i8* %4)
%304 = icmp eq i32 %303, %293
br i1 %304, label %315, label %307
305: ; preds = %291
%306 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.24, i64 0, i64 0))
br label %387
307: ; preds = %299
%308 = load i8*, i8** %0
%309 = ptrtoint i8* %252 to i64
%310 = ptrtoint i8* %308 to i64
%311 = sub i64 %309, %310
%312 = trunc i64 %311 to i32
%313 = tail call i32 @proc_tag(i8** %0, i32 %312, i8** %2, i32* %3, i8* %4)
%314 = icmp slt i32 %313, 0
br i1 %314, label %387, label %315
315: ; preds = %307, %299
%316 = tail call i32 @strlen(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.19, i64 0, i64 0))
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i8, i8* %252, i64 %317
store i8* %318, i8** %0
br label %371
319: ; preds = %240
%320 = tail call i32 @strlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.21, i64 0, i64 0))
%321 = tail call i32 @memcmp(i8* %244, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.21, i64 0, i64 0), i32 %320)
%322 = icmp eq i32 %321, 0
br i1 %322, label %323, label %367
323: ; preds = %319
%324 = load i8*, i8** %2
%325 = load i8*, i8** %0
%326 = sext i32 %12 to i64
%327 = sub nsw i64 0, %326
%328 = getelementptr inbounds i8, i8* %325, i64 %327
%329 = tail call i32 @memcpy(i8* %324, i8* %328, i32 %12)
%330 = load i8*, i8** %2
%331 = getelementptr inbounds i8, i8* %330, i64 %326
store i8* %331, i8** %2
%332 = load i32, i32* %3
%333 = add nsw i32 %332, %12
store i32 %333, i32* %3
%334 = load i8*, i8** %0
%335 = tail call i32 @strlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.21, i64 0, i64 0))
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds i8, i8* %334, i64 %336
%338 = tail call i32 @strlen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%339 = tail call i32 @memcmp(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* %337, i32 %338)
%340 = icmp eq i32 %339, 0
br i1 %340, label %347, label %341
341: ; preds = %323
%342 = tail call i32 @strlen(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
%343 = tail call i32 @memcmp(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), i8* %337, i32 %342)
%344 = icmp eq i32 %343, 0
br i1 %344, label %347, label %345
345: ; preds = %341
%346 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.21, i64 0, i64 0))
br label %387
347: ; preds = %341, %323
%348 = phi i8* [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), %323 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), %341 ]
%349 = phi i32 [ 1, %323 ], [ 0, %341 ]
%350 = tail call i32 @strlen(i8* %348)
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i8, i8* %337, i64 %351
%353 = tail call i8* @strstr(i8* dereferenceable(1) %352, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0))
%354 = icmp eq i8* %353, null
br i1 %354, label %363, label %355
355: ; preds = %347
store i8 0, i8* %353
%356 = tail call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0))
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i8, i8* %353, i64 %357
store i8* %358, i8** %0
%359 = tail call i32 @option_match(i8* %352, i8* %4)
%360 = icmp eq i32 %359, %349
br i1 %360, label %365, label %361
361: ; preds = %355
%362 = load i8*, i8** %0
br label %371
363: ; preds = %347
%364 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.24, i64 0, i64 0))
br label %387
365: ; preds = %355
%366 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.25, i64 0, i64 0))
br label %387
367: ; preds = %319
%368 = load i8*, i8** %0
%369 = getelementptr inbounds i8, i8* %368, i64 1
store i8* %369, i8** %0
%370 = add nsw i32 %12, 1
br label %371
371: ; preds = %361, %45, %85, %125, %236, %367, %315, %145, %105, %68, %22
%372 = phi i8* [ %369, %367 ], [ %362, %361 ], [ %318, %315 ], [ %239, %236 ], [ %159, %145 ], [ %139, %125 ], [ %119, %105 ], [ %99, %85 ], [ %80, %68 ], [ %57, %45 ], [ %34, %22 ]
%373 = phi i32 [ %370, %367 ], [ 0, %361 ], [ 0, %315 ], [ 0, %236 ], [ 0, %145 ], [ 0, %125 ], [ 0, %105 ], [ 0, %85 ], [ 0, %68 ], [ 0, %45 ], [ 0, %22 ]
%374 = icmp ult i8* %372, %8
br i1 %374, label %10, label %375
375: ; preds = %371
%376 = icmp eq i32 %373, 0
br i1 %376, label %387, label %377
377: ; preds = %375
%378 = load i8*, i8** %2
%379 = sext i32 %373 to i64
%380 = sub nsw i64 0, %379
%381 = getelementptr inbounds i8, i8* %372, i64 %380
%382 = tail call i32 @memcpy(i8* %378, i8* %381, i32 %373)
%383 = load i8*, i8** %2
%384 = getelementptr inbounds i8, i8* %383, i64 %379
store i8* %384, i8** %2
%385 = load i32, i32* %3
%386 = add nsw i32 %385, %373
store i32 %386, i32* %3
br label %387
387: ; preds = %307, %228, %5, %375, %377, %365, %363, %345, %305, %289, %254, %226, %210, %175, %66, %43, %20
%388 = phi i32 [ -1, %345 ], [ -1, %365 ], [ -1, %363 ], [ -1, %254 ], [ -1, %289 ], [ -1, %305 ], [ -1, %175 ], [ -1, %210 ], [ -1, %226 ], [ -1, %66 ], [ -1, %43 ], [ -1, %20 ], [ 0, %377 ], [ 0, %375 ], [ 0, %5 ], [ -1, %228 ], [ -1, %307 ]
ret i32 %388
}