#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 */
typedef int /*<<< orphan*/ line;

/* Variables and functions */
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/);
scalar_t__ isalnum(char);
scalar_t__ isspace(char);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sscanf(char const *, char *, char *);
int /*<<< orphan*/ stdin;
scalar_t__ strcmp(char *, char *);
char *strdup(char *);
scalar_t__ strncmp(char *, char *, int);
void *strstr(char const *, char *);
int main(int ac, char *av[]) {
  char line[1024];
  char type[128];
  char type1[128];
  char name[128];
  char ch;
  const char *sp;
  char *tp;
  char *ep;
  char *np;
  char *names[256];
  char *op;
  char *opts[256];
  const char *name1;
  int namex = 0;
  int i;
  int dorw = 0;
  char libname[32];
  char opt[128];
  int skip = 0;
  int lni, lno;
  libname[0] = 0;
  lni = lno = 0;
  for (;;) {
    if (lni != lno) {
      printf("#line %d\n", lni + 1);
      lno = lni;
    }
    if (fgets(line, sizeof(line), stdin) == NULL)
      break;
    lni++;
    if (skip) {
      if (strncmp(line, "#endif", 6) == 0 || strncmp(line, "#else", 5) == 0) {
        skip = 0;
      } else {
        printf("\n");
        lno++;
        continue;
      }
    }
    if (strncmp(line, "#ifdef _MSC_VER", 15) == 0) {
      skip = 1;
    }
    printf("%s", line);
    lno++;
    if (sp = strstr(line, "/*BEGIN_STAB")) {
      if (sp[12] == '(') {
        sscanf(sp + 13, "%[^)]", libname);
      }
      dorw = 1;
      printf("#include <stdio.h> /*DLST*/\n");
      printf("#define PCStr(s) const char *s /*DLST*/\n");
      printf("#define ISDLIB /*DLST*/\n");
      printf("/*DLST*/ typedef struct {const char*name; void*addr; const "
             "char*opt;} DLMap;\n");
      printf("/*DLST*/ extern DLMap dlmap_%s[];\n", libname);
      printf("/*DLST*/ void *dgdlsym(DLMap*,const char *sym);\n");
      printf("#define mydlsym(s) dgdlsym(dlmap_%s,s)\n", libname);
      lno += 7;
    } else if (strstr(line, "/*END_STAB*/")) {
      dorw = 0;
    }
    if (dorw == 0)
      continue;
    sp = line;
    tp = type;
    ep = type;
    np = name;
    type[0] = 0;
    name[0] = 0;
    for (sp = line; ch = *sp; sp++) {
      if (isalnum(ch) || ch == '_')
        break;
    }
    while (ch = *sp) {
      if (!isspace(ch) && !isalnum(ch) && ch != '_' && ch != '*' && ch != '(')
        break;
      if (ch == '(')
        break;
      if (!isalnum(ch) && ch != '_') {
        np = name;
        ep = tp + 1;
      } else {
        *np++ = ch;
      }
      if (tp == type && isspace(ch)) {
      } else {
        *tp++ = ch;
      }
      sp++;
    }
    if (ch != '(') {
      continue;
    }
    if (np == name) {
      continue;
    }
    if (strstr(sp, ");") == 0) {
      continue;
    }
    *tp = 0;
    *ep = 0;
    *np = 0;
    while (type < ep) {
      if (isspace(ep[-1]))
        ep--;
      else
        break;
    }
    *ep = 0;
    if (type[0] == 0)
      continue;
    sscanf(type, "%s", type1);
    if (strcmp(type1, "typedef") == 0 || strcmp(type1, "sizeof") == 0 ||
        strcmp(type1, "return") == 0 || strcmp(type1, "else") == 0)
      continue;
    printf("/*DLST*/ %s", line);
    printf("/*DLST*/ %s (*%s_PTR_)%s", type, name, sp);
    printf("#define %s (*%s_PTR_) /*DLST*/\n", name, name);
    lno += 3;
    if (op = strstr(line, "/*OPT(")) {
      opt[0] = 0;
      sscanf(op + 6, "%[^)]", opt);
      opts[namex] = strdup(opt);
    } else
      opts[namex] = 0;
    names[namex++] = strdup(name);
  }
  names[namex] = 0;
  printf("/*DLST*/ DLMap dlmap_%s[] = {\n", libname);
  printf("/*DLST*/ {\"#%s\"}, /*handle*/\n", libname);
  for (i = 0; i < namex; i++) {
    name1 = names[i];
    if (opts[i])
      printf("/*DLST*/ {\"%s\",&%s_PTR_,\"%s\"},\n", name1, name1, opts[i]);
    else
      printf("/*DLST*/ {\"%s\",&%s_PTR_},\n", name1, name1);
  }
  printf("/*DLST*/ 0};\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x16a0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x15dc(%rbp)
movl   $0x0,-0x15e4(%rbp)
movl   $0x0,-0x1694(%rbp)
movb   $0x0,-0x1610(%rbp)
movl   $0x0,-0x169c(%rbp)
movl   $0x0,-0x1698(%rbp)
mov    -0x1698(%rbp),%eax
cmp    -0x169c(%rbp),%eax
je     1217 <main+0x87>
mov    -0x1698(%rbp),%esi
add    $0x1,%esi
lea    0xdfc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1698(%rbp),%eax
mov    %eax,-0x169c(%rbp)
lea    -0x410(%rbp),%rdi
mov    0x2dc3(%rip),%rax
mov    (%rax),%edx
mov    $0x400,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
jne    1240 <main+0xb0>
jmp    18dd <main+0x74d>
mov    -0x1698(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1698(%rbp)
cmpl   $0x0,-0x1694(%rbp)
je     12d6 <main+0x146>
lea    -0x410(%rbp),%rdi
lea    0xda0(%rip),%rsi
mov    $0x6,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
je     12a0 <main+0x110>
lea    -0x410(%rbp),%rdi
lea    0xd85(%rip),%rsi
mov    $0x5,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    12af <main+0x11f>
movl   $0x0,-0x1694(%rbp)
jmp    12d1 <main+0x141>
lea    0xeab(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x169c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x169c(%rbp)
jmp    11e2 <main+0x52>
jmp    12d6 <main+0x146>
lea    -0x410(%rbp),%rdi
lea    0xd33(%rip),%rsi
mov    $0xf,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1302 <main+0x172>
movl   $0x1,-0x1694(%rbp)
lea    -0x410(%rbp),%rsi
lea    0xe82(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x169c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x169c(%rbp)
lea    -0x410(%rbp),%rdi
lea    0xcf3(%rip),%rsi
call   10b0 <strstr@plt>
mov    %rax,-0x5a0(%rbp)
cmp    $0x0,%rax
je     140a <main+0x27a>
mov    -0x5a0(%rbp),%rax
movsbl 0xc(%rax),%eax
cmp    $0x28,%eax
jne    137c <main+0x1ec>
mov    -0x5a0(%rbp),%rdi
add    $0xd,%rdi
lea    -0x1610(%rbp),%rdx
lea    0xcbd(%rip),%rsi
call   1090 <sscanf@plt>
movl   $0x1,-0x15e4(%rbp)
lea    0xcad(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xcbc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xcd7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xce2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x1610(%rbp),%rsi
lea    0xd1b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xd30(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x1610(%rbp),%rsi
lea    0xd4c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x169c(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x169c(%rbp)
jmp    1436 <main+0x2a6>
lea    -0x410(%rbp),%rdi
lea    0xd4b(%rip),%rsi
call   10b0 <strstr@plt>
cmp    $0x0,%rax
je     1431 <main+0x2a1>
movl   $0x0,-0x15e4(%rbp)
jmp    1436 <main+0x2a6>
cmpl   $0x0,-0x15e4(%rbp)
jne    1448 <main+0x2b8>
jmp    11e2 <main+0x52>
lea    -0x410(%rbp),%rax
mov    %rax,-0x5a0(%rbp)
lea    -0x490(%rbp),%rax
mov    %rax,-0x5a8(%rbp)
lea    -0x490(%rbp),%rax
mov    %rax,-0x5b0(%rbp)
lea    -0x590(%rbp),%rax
mov    %rax,-0x5b8(%rbp)
movb   $0x0,-0x490(%rbp)
movb   $0x0,-0x590(%rbp)
lea    -0x410(%rbp),%rax
mov    %rax,-0x5a0(%rbp)
mov    -0x5a0(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x591(%rbp)
cmp    $0x0,%al
je     14fa <main+0x36a>
movsbl -0x591(%rbp),%edi
call   1050 <isalnum@plt>
cmp    $0x0,%rax
jne    14d9 <main+0x349>
movsbl -0x591(%rbp),%eax
cmp    $0x5f,%eax
jne    14de <main+0x34e>
jmp    14fa <main+0x36a>
jmp    14e3 <main+0x353>
mov    -0x5a0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x5a0(%rbp)
jmp    149c <main+0x30c>
jmp    14ff <main+0x36f>
mov    -0x5a0(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x591(%rbp)
cmp    $0x0,%al
je     165a <main+0x4ca>
movsbl -0x591(%rbp),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
jne    1577 <main+0x3e7>
movsbl -0x591(%rbp),%edi
call   1050 <isalnum@plt>
cmp    $0x0,%rax
jne    1577 <main+0x3e7>
movsbl -0x591(%rbp),%eax
cmp    $0x5f,%eax
je     1577 <main+0x3e7>
movsbl -0x591(%rbp),%eax
cmp    $0x2a,%eax
je     1577 <main+0x3e7>
movsbl -0x591(%rbp),%eax
cmp    $0x28,%eax
je     1577 <main+0x3e7>
jmp    165a <main+0x4ca>
movsbl -0x591(%rbp),%eax
cmp    $0x28,%eax
jne    158c <main+0x3fc>
jmp    165a <main+0x4ca>
movsbl -0x591(%rbp),%edi
call   1050 <isalnum@plt>
cmp    $0x0,%rax
jne    15d7 <main+0x447>
movsbl -0x591(%rbp),%eax
cmp    $0x5f,%eax
je     15d7 <main+0x447>
lea    -0x590(%rbp),%rax
mov    %rax,-0x5b8(%rbp)
mov    -0x5a8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x5b0(%rbp)
jmp    15f4 <main+0x464>
mov    -0x591(%rbp),%cl
mov    -0x5b8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x5b8(%rbp)
mov    %cl,(%rax)
mov    -0x5a8(%rbp),%rax
lea    -0x490(%rbp),%rcx
cmp    %rcx,%rax
jne    1626 <main+0x496>
movsbl -0x591(%rbp),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
je     1626 <main+0x496>
jmp    1643 <main+0x4b3>
mov    -0x591(%rbp),%cl
mov    -0x5a8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x5a8(%rbp)
mov    %cl,(%rax)
mov    -0x5a0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x5a0(%rbp)
jmp    14ff <main+0x36f>
movsbl -0x591(%rbp),%eax
cmp    $0x28,%eax
je     166f <main+0x4df>
jmp    11e2 <main+0x52>
mov    -0x5b8(%rbp),%rax
lea    -0x590(%rbp),%rcx
cmp    %rcx,%rax
jne    168b <main+0x4fb>
jmp    11e2 <main+0x52>
mov    -0x5a0(%rbp),%rdi
lea    0xad7(%rip),%rsi
call   10b0 <strstr@plt>
cmp    $0x0,%rax
jne    16ad <main+0x51d>
jmp    11e2 <main+0x52>
mov    -0x5a8(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x5b0(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x5b8(%rbp),%rax
movb   $0x0,(%rax)
lea    -0x490(%rbp),%rax
cmp    -0x5b0(%rbp),%rax
jae    171a <main+0x58a>
mov    -0x5b0(%rbp),%rax
movsbl -0x1(%rax),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
je     1710 <main+0x580>
mov    -0x5b0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x5b0(%rbp)
jmp    1715 <main+0x585>
jmp    171a <main+0x58a>
jmp    16cb <main+0x53b>
mov    -0x5b0(%rbp),%rax
movb   $0x0,(%rax)
movsbl -0x490(%rbp),%eax
cmp    $0x0,%eax
jne    1739 <main+0x5a9>
jmp    11e2 <main+0x52>
lea    -0x490(%rbp),%rdi
lea    -0x510(%rbp),%rdx
lea    0xa44(%rip),%rsi
call   1090 <sscanf@plt>
lea    -0x510(%rbp),%rdi
lea    0xa12(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
je     17c7 <main+0x637>
lea    -0x510(%rbp),%rdi
lea    0x9fd(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
je     17c7 <main+0x637>
lea    -0x510(%rbp),%rdi
lea    0x9e7(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
je     17c7 <main+0x637>
lea    -0x510(%rbp),%rdi
lea    0x85a(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    17cc <main+0x63c>
jmp    11e2 <main+0x52>
lea    -0x410(%rbp),%rsi
lea    0x9af(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x490(%rbp),%rsi
lea    -0x590(%rbp),%rdx
mov    -0x5a0(%rbp),%rcx
lea    0x998(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x590(%rbp),%rsi
lea    -0x590(%rbp),%rdx
lea    0x995(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x169c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x169c(%rbp)
lea    -0x410(%rbp),%rdi
lea    0x991(%rip),%rsi
call   10b0 <strstr@plt>
mov    %rax,-0xdc8(%rbp)
cmp    $0x0,%rax
je     189b <main+0x70b>
movb   $0x0,-0x1690(%rbp)
mov    -0xdc8(%rbp),%rdi
add    $0x6,%rdi
lea    -0x1690(%rbp),%rdx
lea    0x7c1(%rip),%rsi
call   1090 <sscanf@plt>
lea    -0x1690(%rbp),%rdi
call   10a0 <strdup@plt>
mov    %rax,%rcx
movslq -0x15dc(%rbp),%rax
mov    %rcx,-0x15d0(%rbp,%rax,8)
ff
jmp    18ae <main+0x71e>
movslq -0x15dc(%rbp),%rax
movq   $0x0,-0x15d0(%rbp,%rax,8)
lea    -0x590(%rbp),%rdi
call   10a0 <strdup@plt>
mov    %rax,%rcx
mov    -0x15dc(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x15dc(%rbp)
cltq
mov    %rcx,-0xdc0(%rbp,%rax,8)
ff
jmp    11e2 <main+0x52>
movslq -0x15dc(%rbp),%rax
movq   $0x0,-0xdc0(%rbp,%rax,8)
lea    -0x1610(%rbp),%rsi
lea    0x8d7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x1610(%rbp),%rsi
lea    0x8e1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x15e0(%rbp)
mov    -0x15e0(%rbp),%eax
cmp    -0x15dc(%rbp),%eax
jge    19c7 <main+0x837>
movslq -0x15e0(%rbp),%rax
mov    -0xdc0(%rbp,%rax,8),%rax
ff
mov    %rax,-0x15d8(%rbp)
movslq -0x15e0(%rbp),%rax
cmpq   $0x0,-0x15d0(%rbp,%rax,8)
je     1992 <main+0x802>
mov    -0x15d8(%rbp),%rsi
mov    -0x15d8(%rbp),%rdx
movslq -0x15e0(%rbp),%rax
mov    -0x15d0(%rbp,%rax,8),%rcx
ff
lea    0x88c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    19ae <main+0x81e>
mov    -0x15d8(%rbp),%rsi
mov    -0x15d8(%rbp),%rdx
lea    0x88b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    19b3 <main+0x823>
mov    -0x15e0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15e0(%rbp)
jmp    1924 <main+0x794>
lea    0x87f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x16a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1658,%rsp
movb   $0x0,0x30(%rsp)
movl   $0x0,0x14(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
movl   $0x0,0xc(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
xor    %ebp,%ebp
xor    %ecx,%ecx
mov    0xc(%rsp),%eax
mov    %eax,0x18(%rsp)
mov    %ebp,%r15d
lea    0x250(%rsp),%rbx
lea    0xe08(%rip),%rbp
lea    0xe08(%rip),%r12
lea    0xdf0(%rip),%r13
cmp    %ecx,%r15d
je     122e <main+0x7e>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%r15),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x2db3(%rip),%rax
mov    (%rax),%edx
mov    %rbx,%rdi
mov    $0x400,%esi
call   1090 <fgets@plt>
test   %rax,%rax
je     172d <main+0x57d>
testb  $0x1,0x28(%rsp)
je     12b0 <main+0x100>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x6,%edx
call   1040 <strncmp@plt>
test   %rax,%rax
je     12b0 <main+0x100>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    $0x5,%edx
call   1040 <strncmp@plt>
test   %rax,%rax
je     12b0 <main+0x100>
lea    0x1(%r15),%r14d
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r14d,%ecx
add    $0x1,%r15d
mov    $0x1,%al
mov    %rax,0x28(%rsp)
cmp    %ecx,%r15d
jne    1220 <main+0x70>
jmp    122e <main+0x7e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
lea    0xd5d(%rip),%rsi
mov    $0xf,%edx
call   1040 <strncmp@plt>
test   %rax,%rax
sete   %bpl
lea    0xddf(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbx,%rdi
lea    0xd41(%rip),%rsi
call   10d0 <strstr@plt>
lea    0x1(%r15),%r14d
test   %rax,%rax
mov    %rbp,0x28(%rsp)
je     1390 <main+0x1e0>
cmpb   $0x28,0xc(%rax)
jne    131b <main+0x16b>
add    $0xd,%rax
mov    %rax,%rdi
lea    0xd23(%rip),%rsi
lea    0x30(%rsp),%rdx
call   10b0 <sscanf@plt>
lea    0xe4a(%rip),%rdi
call   1050 <puts@plt>
lea    0xe5a(%rip),%rdi
call   1050 <puts@plt>
lea    0xe76(%rip),%rdi
call   1050 <puts@plt>
lea    0xe82(%rip),%rdi
call   1050 <puts@plt>
lea    0xce8(%rip),%rdi
lea    0x30(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xead(%rip),%rdi
call   1050 <puts@plt>
lea    0xce9(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x8(%r15),%ecx
mov    %r14d,%ebp
jmp    13c3 <main+0x213>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
lea    0xceb(%rip),%rsi
call   10d0 <strstr@plt>
movl   $0x0,0xc(%rsp)
mov    %r14d,%ecx
test   %rax,%rax
mov    %r14d,%ebp
jne    11e8 <main+0x38>
mov    %ebp,%ecx
cmpl   $0x0,0x18(%rsp)
je     11e8 <main+0x38>
movb   $0x0,0x50(%rsp)
movb   $0x0,0xd0(%rsp)
mov    0x250(%rsp),%bl
movl   $0x1,0xc(%rsp)
test   %bl,%bl
je     11e8 <main+0x38>
mov    %ecx,0x8(%rsp)
lea    0x250(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl %bl,%edi
call   1070 <isalnum@plt>
test   %rax,%rax
jne    1429 <main+0x279>
cmp    $0x5f,%bl
je     1429 <main+0x279>
movzbl 0x1(%r12),%ebx
add    $0x1,%r12
test   %bl,%bl
jne    1400 <main+0x250>
mov    0x8(%rsp),%ecx
jmp    11e8 <main+0x38>
mov    (%r12),%r14b
test   %r14b,%r14b
mov    0x8(%rsp),%ecx
je     11e8 <main+0x38>
mov    %ebp,0x10(%rsp)
lea    0xd0(%rsp),%rbx
lea    0x50(%rsp),%r13
mov    %r13,0x18(%rsp)
jmp    1481 <main+0x2d1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14b,0x0(%r13)
add    $0x1,%r13
mov    %r13,%rcx
movzbl 0x1(%r12),%r14d
add    $0x1,%r12
mov    %rcx,%r13
test   %r14b,%r14b
je     16d1 <main+0x521>
movsbl %r14b,%ebp
mov    %ebp,%edi
call   1080 <isspace@plt>
test   %rax,%rax
jne    14b2 <main+0x302>
mov    %ebp,%edi
call   1070 <isalnum@plt>
test   %rax,%rax
sete   %al
cmp    $0x5f,%r14b
setne  %cl
and    %al,%cl
cmp    $0x2a,%r14b
setne  %al
test   %al,%cl
jne    150f <main+0x35f>
cmp    $0x28,%r14b
je     150f <main+0x35f>
mov    %ebp,%edi
call   1070 <isalnum@plt>
test   %rax,%rax
jne    14e0 <main+0x330>
cmp    $0x5f,%r14b
je     14e0 <main+0x330>
lea    0x1(%r13),%rax
mov    %rax,0x18(%rsp)
lea    0xd0(%rsp),%rbx
jmp    14e7 <main+0x337>
nopl   (%rax)
mov    %r14b,(%rbx)
add    $0x1,%rbx
lea    0x50(%rsp),%rax
cmp    %rax,%r13
jne    1460 <main+0x2b0>
mov    %ebp,%edi
call   1080 <isspace@plt>
lea    0x50(%rsp),%rcx
test   %rax,%rax
jne    146b <main+0x2bb>
jmp    1460 <main+0x2b0>
cmp    $0x28,%r14b
mov    0x8(%rsp),%ecx
mov    0x10(%rsp),%ebp
jne    11e8 <main+0x38>
lea    0xd0(%rsp),%rax
cmp    %rax,%rbx
je     11e8 <main+0x38>
mov    %r12,%rdi
lea    0xd06(%rip),%rsi
call   10d0 <strstr@plt>
mov    0x8(%rsp),%ecx
test   %rax,%rax
je     11e8 <main+0x38>
mov    %ebp,%r14d
movb   $0x0,0x0(%r13)
mov    0x18(%rsp),%rbp
movb   $0x0,0x0(%rbp)
movb   $0x0,(%rbx)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%rbx
lea    0x50(%rsp),%rax
cmp    %rbp,%rax
jae    158f <main+0x3df>
lea    -0x1(%rbx),%rbp
movsbl -0x1(%rbx),%edi
call   1080 <isspace@plt>
test   %rax,%rax
jne    1570 <main+0x3c0>
movb   $0x0,(%rbx)
cmpb   $0x0,0x50(%rsp)
mov    0x8(%rsp),%ecx
mov    %r14d,%ebp
je     11e8 <main+0x38>
lea    0x50(%rsp),%rdi
lea    0xb01(%rip),%rsi
lea    0x150(%rsp),%rbx
mov    %rbx,%rdx
call   10b0 <sscanf@plt>
mov    %rbx,%rdi
lea    0xac8(%rip),%rsi
call   10a0 <strcmp@plt>
mov    0x8(%rsp),%ecx
test   %rax,%rax
je     11e8 <main+0x38>
lea    0x150(%rsp),%rdi
lea    0xaaf(%rip),%rsi
call   10a0 <strcmp@plt>
mov    0x8(%rsp),%ecx
test   %rax,%rax
je     11e8 <main+0x38>
lea    0x150(%rsp),%rdi
lea    0xa95(%rip),%rsi
call   10a0 <strcmp@plt>
mov    0x8(%rsp),%ecx
test   %rax,%rax
je     11e8 <main+0x38>
lea    0x150(%rsp),%rdi
lea    0x9e5(%rip),%rsi
call   10a0 <strcmp@plt>
mov    0x8(%rsp),%ecx
test   %rax,%rax
je     11e8 <main+0x38>
lea    0xa62(%rip),%rdi
lea    0x250(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xa55(%rip),%rdi
lea    0x50(%rsp),%rsi
lea    0xd0(%rsp),%rbp
mov    %rbp,%rdx
mov    %r12,%rcx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xa4d(%rip),%rdi
mov    %rbp,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbx,%rdi
lea    0xa56(%rip),%rsi
call   10d0 <strstr@plt>
test   %rax,%rax
je     16de <main+0x52e>
movb   $0x0,0x1d0(%rsp)
add    $0x6,%rax
mov    %rax,%rdi
lea    0x97d(%rip),%rsi
lea    0x1d0(%rsp),%rbx
mov    %rbx,%rdx
call   10b0 <sscanf@plt>
mov    %rbx,%rdi
call   10c0 <strdup@plt>
jmp    16e0 <main+0x530>
mov    0x8(%rsp),%ecx
mov    0x10(%rsp),%ebp
jmp    11e8 <main+0x38>
xor    %eax,%eax
mov    0x8(%rsp),%ebp
add    $0x3,%ebp
add    $0x1,%r15d
mov    0x20(%rsp),%rbx
mov    %rax,0xe50(%rsp,%rbx,8)
lea    0xd0(%rsp),%rdi
call   10c0 <strdup@plt>
mov    %ebp,%ecx
mov    %rax,0x650(%rsp,%rbx,8)
add    $0x1,%rbx
mov    %rbx,0x20(%rsp)
addl   $0x1,0x14(%rsp)
movl   $0x1,0xc(%rsp)
mov    %r15d,%ebp
jmp    11e8 <main+0x38>
mov    0x20(%rsp),%rbp
mov    %ebp,%eax
movq   $0x0,0x650(%rsp,%rax,8)
lea    0x9ad(%rip),%rdi
lea    0x30(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x9b6(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
test   %ebp,%ebp
je     17ca <main+0x61a>
mov    0x14(%rsp),%ebx
lea    0x9db(%rip),%r14
lea    0x9b4(%rip),%r15
xor    %ebp,%ebp
jmp    17a6 <main+0x5f6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rdx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
je     17ca <main+0x61a>
mov    0x650(%rsp,%rbp,8),%rdx
mov    0xe50(%rsp,%rbp,8),%rcx
test   %rcx,%rcx
je     1790 <main+0x5e0>
mov    %r15,%rdi
mov    %rdx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    179d <main+0x5ed>
lea    0xa74(%rip),%rdi
call   1050 <puts@plt>
xor    %eax,%eax
add    $0x1658,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [10 x i8] c"#line %d\0A\00"
@stdin = global i32 0
@.str.1 = [7 x i8] c"#endif\00"
@.str.2 = [6 x i8] c"#else\00"
@.str.3 = [2 x i8] c"\0A\00"
@.str.4 = [16 x i8] c"#ifdef _MSC_VER\00"
@.str.5 = [3 x i8] c"%s\00"
@.str.6 = [13 x i8] c"/*BEGIN_STAB\00"
@.str.7 = [6 x i8] c"%[^)]\00"
@.str.8 = [29 x i8] c"#include <stdio.h> /*DLST*/\0A\00"
@.str.9 = [41 x i8] c"#define PCStr(s) const char *s /*DLST*/\0A\00"
@.str.10 = [25 x i8] c"#define ISDLIB /*DLST*/\0A\00"
@.str.11 = [78 x i8] c"/*DLST*/ typedef struct {const char*name; void*addr; const char*opt;} DLMap;\0A\00"
@.str.12 = [35 x i8] c"/*DLST*/ extern DLMap dlmap_%s[];\0A\00"
@.str.13 = [49 x i8] c"/*DLST*/ void *dgdlsym(DLMap*,const char *sym);\0A\00"
@.str.14 = [40 x i8] c"#define mydlsym(s) dgdlsym(dlmap_%s,s)\0A\00"
@.str.15 = [13 x i8] c"/*END_STAB*/\00"
@.str.16 = [3 x i8] c");\00"
@.str.17 = [8 x i8] c"typedef\00"
@.str.18 = [7 x i8] c"sizeof\00"
@.str.19 = [7 x i8] c"return\00"
@.str.20 = [5 x i8] c"else\00"
@.str.21 = [12 x i8] c"/*DLST*/ %s\00"
@.str.22 = [25 x i8] c"/*DLST*/ %s (*%s_PTR_)%s\00"
@.str.23 = [32 x i8] c"#define %s (*%s_PTR_) /*DLST*/\0A\00"
@.str.24 = [7 x i8] c"/*OPT(\00"
@.str.25 = [31 x i8] c"/*DLST*/ DLMap dlmap_%s[] = {\0A\00"
@.str.26 = [30 x i8] c"/*DLST*/ {\22#%s\22}, /*handle*/\0A\00"
@.str.27 = [32 x i8] c"/*DLST*/ {\22%s\22,&%s_PTR_,\22%s\22},\0A\00"
@.str.28 = [27 x i8] c"/*DLST*/ {\22%s\22,&%s_PTR_},\0A\00"
@.str.29 = [14 x i8] c"/*DLST*/ 0};\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [1024 x i8]
%7 = alloca [128 x i8]
%8 = alloca [128 x i8]
%9 = alloca [128 x i8]
%10 = alloca i8
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca [256 x i8*]
%16 = alloca i8*
%17 = alloca [256 x i8*]
%18 = alloca i8*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca [32 x i8]
%23 = alloca [128 x i8]
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %19
store i32 0, i32* %21
store i32 0, i32* %24
%27 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 0
store i8 0, i8* %27
store i32 0, i32* %26
store i32 0, i32* %25
br label %28
28: ; preds = %287, %256, %236, %210, %205, %200, %107, %57, %2
%29 = load i32, i32* %25
%30 = load i32, i32* %26
%31 = icmp ne i32 %29, %30
br i1 %31, label %32, label %37
32: ; preds = %28
%33 = load i32, i32* %25
%34 = add nsw i32 %33, 1
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i32 %34)
%36 = load i32, i32* %25
store i32 %36, i32* %26
br label %37
37: ; preds = %32, %28
%38 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%39 = load i32, i32* @stdin
%40 = call i32* @fgets(i8* %38, i32 1024, i32 %39)
%41 = icmp eq i32* %40, null
br i1 %41, label %42, label %43
42: ; preds = %37
br label %294
43: ; preds = %37
%44 = load i32, i32* %25
%45 = add nsw i32 %44, 1
store i32 %45, i32* %25
%46 = load i32, i32* %24
%47 = icmp ne i32 %46, 0
br i1 %47, label %48, label %62
48: ; preds = %43
%49 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%50 = call i64 @strncmp(i8* %49, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 6)
%51 = icmp eq i64 %50, 0
br i1 %51, label %56, label %52
52: ; preds = %48
%53 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%54 = call i64 @strncmp(i8* %53, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 5)
%55 = icmp eq i64 %54, 0
br i1 %55, label %56, label %57
56: ; preds = %52, %48
store i32 0, i32* %24
br label %61
57: ; preds = %52
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%59 = load i32, i32* %26
%60 = add nsw i32 %59, 1
store i32 %60, i32* %26
br label %28
61: ; preds = %56
br label %62
62: ; preds = %61, %43
%63 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%64 = call i64 @strncmp(i8* %63, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 15)
%65 = icmp eq i64 %64, 0
br i1 %65, label %66, label %67
66: ; preds = %62
store i32 1, i32* %24
br label %67
67: ; preds = %66, %62
%68 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %68)
%70 = load i32, i32* %26
%71 = add nsw i32 %70, 1
store i32 %71, i32* %26
%72 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%73 = call i8* @strstr(i8* %72, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i64 0, i64 0))
store i8* %73, i8** %11
%74 = icmp ne i8* %73, null
br i1 %74, label %75, label %98
75: ; preds = %67
%76 = load i8*, i8** %11
%77 = getelementptr inbounds i8, i8* %76, i64 12
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = icmp eq i32 %79, 40
br i1 %80, label %81, label %86
81: ; preds = %75
%82 = load i8*, i8** %11
%83 = getelementptr inbounds i8, i8* %82, i64 13
%84 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 0
%85 = call i32 @sscanf(i8* %83, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* %84)
br label %86
86: ; preds = %81, %75
store i32 1, i32* %21
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.8, i64 0, i64 0))
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.9, i64 0, i64 0))
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.10, i64 0, i64 0))
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.11, i64 0, i64 0))
%91 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 0
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.12, i64 0, i64 0), i8* %91)
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.13, i64 0, i64 0))
%94 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 0
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.14, i64 0, i64 0), i8* %94)
%96 = load i32, i32* %26
%97 = add nsw i32 %96, 7
store i32 %97, i32* %26
br label %104
98: ; preds = %67
%99 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%100 = call i8* @strstr(i8* %99, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.15, i64 0, i64 0))
%101 = icmp ne i8* %100, null
br i1 %101, label %102, label %103
102: ; preds = %98
store i32 0, i32* %21
br label %103
103: ; preds = %102, %98
br label %104
104: ; preds = %103, %86
%105 = load i32, i32* %21
%106 = icmp eq i32 %105, 0
br i1 %106, label %107, label %108
107: ; preds = %104
br label %28
108: ; preds = %104
%109 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
store i8* %109, i8** %11
%110 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
store i8* %110, i8** %12
%111 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
store i8* %111, i8** %13
%112 = getelementptr inbounds [128 x i8], [128 x i8]* %9, i64 0, i64 0
store i8* %112, i8** %14
%113 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
store i8 0, i8* %113
%114 = getelementptr inbounds [128 x i8], [128 x i8]* %9, i64 0, i64 0
store i8 0, i8* %114
%115 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
store i8* %115, i8** %11
br label %116
116: ; preds = %130, %108
%117 = load i8*, i8** %11
%118 = load i8, i8* %117
store i8 %118, i8* %10
%119 = icmp ne i8 %118, 0
br i1 %119, label %120, label %133
120: ; preds = %116
%121 = load i8, i8* %10
%122 = call i64 @isalnum(i8 signext %121)
%123 = icmp ne i64 %122, 0
br i1 %123, label %128, label %124
124: ; preds = %120
%125 = load i8, i8* %10
%126 = sext i8 %125 to i32
%127 = icmp eq i32 %126, 95
br i1 %127, label %128, label %129
128: ; preds = %124, %120
br label %133
129: ; preds = %124
br label %130
130: ; preds = %129
%131 = load i8*, i8** %11
%132 = getelementptr inbounds i8, i8* %131, i32 1
store i8* %132, i8** %11
br label %116
133: ; preds = %128, %116
br label %134
134: ; preds = %193, %133
%135 = load i8*, i8** %11
%136 = load i8, i8* %135
store i8 %136, i8* %10
%137 = icmp ne i8 %136, 0
br i1 %137, label %138, label %196
138: ; preds = %134
%139 = load i8, i8* %10
%140 = call i64 @isspace(i8 signext %139)
%141 = icmp ne i64 %140, 0
br i1 %141, label %159, label %142
142: ; preds = %138
%143 = load i8, i8* %10
%144 = call i64 @isalnum(i8 signext %143)
%145 = icmp ne i64 %144, 0
br i1 %145, label %159, label %146
146: ; preds = %142
%147 = load i8, i8* %10
%148 = sext i8 %147 to i32
%149 = icmp ne i32 %148, 95
br i1 %149, label %150, label %159
150: ; preds = %146
%151 = load i8, i8* %10
%152 = sext i8 %151 to i32
%153 = icmp ne i32 %152, 42
br i1 %153, label %154, label %159
154: ; preds = %150
%155 = load i8, i8* %10
%156 = sext i8 %155 to i32
%157 = icmp ne i32 %156, 40
br i1 %157, label %158, label %159
158: ; preds = %154
br label %196
159: ; preds = %154, %150, %146, %142, %138
%160 = load i8, i8* %10
%161 = sext i8 %160 to i32
%162 = icmp eq i32 %161, 40
br i1 %162, label %163, label %164
163: ; preds = %159
br label %196
164: ; preds = %159
%165 = load i8, i8* %10
%166 = call i64 @isalnum(i8 signext %165)
%167 = icmp ne i64 %166, 0
br i1 %167, label %176, label %168
168: ; preds = %164
%169 = load i8, i8* %10
%170 = sext i8 %169 to i32
%171 = icmp ne i32 %170, 95
br i1 %171, label %172, label %176
172: ; preds = %168
%173 = getelementptr inbounds [128 x i8], [128 x i8]* %9, i64 0, i64 0
store i8* %173, i8** %14
%174 = load i8*, i8** %12
%175 = getelementptr inbounds i8, i8* %174, i64 1
store i8* %175, i8** %13
br label %180
176: ; preds = %168, %164
%177 = load i8, i8* %10
%178 = load i8*, i8** %14
%179 = getelementptr inbounds i8, i8* %178, i32 1
store i8* %179, i8** %14
store i8 %177, i8* %178
br label %180
180: ; preds = %176, %172
%181 = load i8*, i8** %12
%182 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
%183 = icmp eq i8* %181, %182
br i1 %183, label %184, label %189
184: ; preds = %180
%185 = load i8, i8* %10
%186 = call i64 @isspace(i8 signext %185)
%187 = icmp ne i64 %186, 0
br i1 %187, label %188, label %189
188: ; preds = %184
br label %193
189: ; preds = %184, %180
%190 = load i8, i8* %10
%191 = load i8*, i8** %12
%192 = getelementptr inbounds i8, i8* %191, i32 1
store i8* %192, i8** %12
store i8 %190, i8* %191
br label %193
193: ; preds = %189, %188
%194 = load i8*, i8** %11
%195 = getelementptr inbounds i8, i8* %194, i32 1
store i8* %195, i8** %11
br label %134
196: ; preds = %163, %158, %134
%197 = load i8, i8* %10
%198 = sext i8 %197 to i32
%199 = icmp ne i32 %198, 40
br i1 %199, label %200, label %201
200: ; preds = %196
br label %28
201: ; preds = %196
%202 = load i8*, i8** %14
%203 = getelementptr inbounds [128 x i8], [128 x i8]* %9, i64 0, i64 0
%204 = icmp eq i8* %202, %203
br i1 %204, label %205, label %206
205: ; preds = %201
br label %28
206: ; preds = %201
%207 = load i8*, i8** %11
%208 = call i8* @strstr(i8* %207, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%209 = icmp eq i8* %208, null
br i1 %209, label %210, label %211
210: ; preds = %206
br label %28
211: ; preds = %206
%212 = load i8*, i8** %12
store i8 0, i8* %212
%213 = load i8*, i8** %13
store i8 0, i8* %213
%214 = load i8*, i8** %14
store i8 0, i8* %214
br label %215
215: ; preds = %229, %211
%216 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
%217 = load i8*, i8** %13
%218 = icmp ult i8* %216, %217
br i1 %218, label %219, label %230
219: ; preds = %215
%220 = load i8*, i8** %13
%221 = getelementptr inbounds i8, i8* %220, i64 -1
%222 = load i8, i8* %221
%223 = call i64 @isspace(i8 signext %222)
%224 = icmp ne i64 %223, 0
br i1 %224, label %225, label %228
225: ; preds = %219
%226 = load i8*, i8** %13
%227 = getelementptr inbounds i8, i8* %226, i32 -1
store i8* %227, i8** %13
br label %229
228: ; preds = %219
br label %230
229: ; preds = %225
br label %215
230: ; preds = %228, %215
%231 = load i8*, i8** %13
store i8 0, i8* %231
%232 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
%233 = load i8, i8* %232
%234 = sext i8 %233 to i32
%235 = icmp eq i32 %234, 0
br i1 %235, label %236, label %237
236: ; preds = %230
br label %28
237: ; preds = %230
%238 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
%239 = getelementptr inbounds [128 x i8], [128 x i8]* %8, i64 0, i64 0
%240 = call i32 @sscanf(i8* %238, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %239)
%241 = getelementptr inbounds [128 x i8], [128 x i8]* %8, i64 0, i64 0
%242 = call i64 @strcmp(i8* %241, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.17, i64 0, i64 0))
%243 = icmp eq i64 %242, 0
br i1 %243, label %256, label %244
244: ; preds = %237
%245 = getelementptr inbounds [128 x i8], [128 x i8]* %8, i64 0, i64 0
%246 = call i64 @strcmp(i8* %245, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.18, i64 0, i64 0))
%247 = icmp eq i64 %246, 0
br i1 %247, label %256, label %248
248: ; preds = %244
%249 = getelementptr inbounds [128 x i8], [128 x i8]* %8, i64 0, i64 0
%250 = call i64 @strcmp(i8* %249, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.19, i64 0, i64 0))
%251 = icmp eq i64 %250, 0
br i1 %251, label %256, label %252
252: ; preds = %248
%253 = getelementptr inbounds [128 x i8], [128 x i8]* %8, i64 0, i64 0
%254 = call i64 @strcmp(i8* %253, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.20, i64 0, i64 0))
%255 = icmp eq i64 %254, 0
br i1 %255, label %256, label %257
256: ; preds = %252, %248, %244, %237
br label %28
257: ; preds = %252
%258 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%259 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.21, i64 0, i64 0), i8* %258)
%260 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
%261 = getelementptr inbounds [128 x i8], [128 x i8]* %9, i64 0, i64 0
%262 = load i8*, i8** %11
%263 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.22, i64 0, i64 0), i8* %260, i8* %261, i8* %262)
%264 = getelementptr inbounds [128 x i8], [128 x i8]* %9, i64 0, i64 0
%265 = getelementptr inbounds [128 x i8], [128 x i8]* %9, i64 0, i64 0
%266 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.23, i64 0, i64 0), i8* %264, i8* %265)
%267 = load i32, i32* %26
%268 = add nsw i32 %267, 3
store i32 %268, i32* %26
%269 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 0
%270 = call i8* @strstr(i8* %269, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0))
store i8* %270, i8** %16
%271 = icmp ne i8* %270, null
br i1 %271, label %272, label %283
272: ; preds = %257
%273 = getelementptr inbounds [128 x i8], [128 x i8]* %23, i64 0, i64 0
store i8 0, i8* %273
%274 = load i8*, i8** %16
%275 = getelementptr inbounds i8, i8* %274, i64 6
%276 = getelementptr inbounds [128 x i8], [128 x i8]* %23, i64 0, i64 0
%277 = call i32 @sscanf(i8* %275, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* %276)
%278 = getelementptr inbounds [128 x i8], [128 x i8]* %23, i64 0, i64 0
%279 = call i8* @strdup(i8* %278)
%280 = load i32, i32* %19
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds [256 x i8*], [256 x i8*]* %17, i64 0, i64 %281
store i8* %279, i8** %282
br label %287
283: ; preds = %257
%284 = load i32, i32* %19
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [256 x i8*], [256 x i8*]* %17, i64 0, i64 %285
store i8* null, i8** %286
br label %287
287: ; preds = %283, %272
%288 = getelementptr inbounds [128 x i8], [128 x i8]* %9, i64 0, i64 0
%289 = call i8* @strdup(i8* %288)
%290 = load i32, i32* %19
%291 = add nsw i32 %290, 1
store i32 %291, i32* %19
%292 = sext i32 %290 to i64
%293 = getelementptr inbounds [256 x i8*], [256 x i8*]* %15, i64 0, i64 %292
store i8* %289, i8** %293
br label %28
294: ; preds = %42
%295 = load i32, i32* %19
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds [256 x i8*], [256 x i8*]* %15, i64 0, i64 %296
store i8* null, i8** %297
%298 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 0
%299 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.25, i64 0, i64 0), i8* %298)
%300 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 0
%301 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.26, i64 0, i64 0), i8* %300)
store i32 0, i32* %20
br label %302
302: ; preds = %329, %294
%303 = load i32, i32* %20
%304 = load i32, i32* %19
%305 = icmp slt i32 %303, %304
br i1 %305, label %306, label %332
306: ; preds = %302
%307 = load i32, i32* %20
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [256 x i8*], [256 x i8*]* %15, i64 0, i64 %308
%310 = load i8*, i8** %309
store i8* %310, i8** %18
%311 = load i32, i32* %20
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [256 x i8*], [256 x i8*]* %17, i64 0, i64 %312
%314 = load i8*, i8** %313
%315 = icmp ne i8* %314, null
br i1 %315, label %316, label %324
316: ; preds = %306
%317 = load i8*, i8** %18
%318 = load i8*, i8** %18
%319 = load i32, i32* %20
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds [256 x i8*], [256 x i8*]* %17, i64 0, i64 %320
%322 = load i8*, i8** %321
%323 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.27, i64 0, i64 0), i8* %317, i8* %318, i8* %322)
br label %328
324: ; preds = %306
%325 = load i8*, i8** %18
%326 = load i8*, i8** %18
%327 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.28, i64 0, i64 0), i8* %325, i8* %326)
br label %328
328: ; preds = %324, %316
br label %329
329: ; preds = %328
%330 = load i32, i32* %20
%331 = add nsw i32 %330, 1
store i32 %331, i32* %20
br label %302
332: ; preds = %302
%333 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.29, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@.str = [10 x i8] c"#line %d\0A\00"
@stdin = global i32 0
@.str.1 = [7 x i8] c"#endif\00"
@.str.2 = [6 x i8] c"#else\00"
@.str.4 = [16 x i8] c"#ifdef _MSC_VER\00"
@.str.5 = [3 x i8] c"%s\00"
@.str.6 = [13 x i8] c"/*BEGIN_STAB\00"
@.str.7 = [6 x i8] c"%[^)]\00"
@.str.12 = [35 x i8] c"/*DLST*/ extern DLMap dlmap_%s[];\0A\00"
@.str.14 = [40 x i8] c"#define mydlsym(s) dgdlsym(dlmap_%s,s)\0A\00"
@.str.15 = [13 x i8] c"/*END_STAB*/\00"
@.str.16 = [3 x i8] c");\00"
@.str.17 = [8 x i8] c"typedef\00"
@.str.18 = [7 x i8] c"sizeof\00"
@.str.19 = [7 x i8] c"return\00"
@.str.20 = [5 x i8] c"else\00"
@.str.21 = [12 x i8] c"/*DLST*/ %s\00"
@.str.22 = [25 x i8] c"/*DLST*/ %s (*%s_PTR_)%s\00"
@.str.23 = [32 x i8] c"#define %s (*%s_PTR_) /*DLST*/\0A\00"
@.str.24 = [7 x i8] c"/*OPT(\00"
@.str.25 = [31 x i8] c"/*DLST*/ DLMap dlmap_%s[] = {\0A\00"
@.str.26 = [30 x i8] c"/*DLST*/ {\22#%s\22}, /*handle*/\0A\00"
@.str.27 = [32 x i8] c"/*DLST*/ {\22%s\22,&%s_PTR_,\22%s\22},\0A\00"
@.str.28 = [27 x i8] c"/*DLST*/ {\22%s\22,&%s_PTR_},\0A\00"
@str = [28 x i8] c"#include <stdio.h> /*DLST*/\00"
@str.30 = [40 x i8] c"#define PCStr(s) const char *s /*DLST*/\00"
@str.31 = [24 x i8] c"#define ISDLIB /*DLST*/\00"
@str.32 = [77 x i8] c"/*DLST*/ typedef struct {const char*name; void*addr; const char*opt;} DLMap;\00"
@str.33 = [48 x i8] c"/*DLST*/ void *dgdlsym(DLMap*,const char *sym);\00"
@str.34 = [13 x i8] c"/*DLST*/ 0};\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [1024 x i8]
%4 = alloca [128 x i8]
%5 = alloca [128 x i8]
%6 = alloca [128 x i8]
%7 = alloca [256 x i8*]
%8 = alloca [256 x i8*]
%9 = alloca [32 x i8]
%10 = alloca [128 x i8]
%11 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 0
%12 = getelementptr inbounds [128 x i8], [128 x i8]* %4, i64 0, i64 0
%13 = getelementptr inbounds [128 x i8], [128 x i8]* %5, i64 0, i64 0
%14 = getelementptr inbounds [128 x i8], [128 x i8]* %6, i64 0, i64 0
%15 = bitcast [256 x i8*]* %7 to i8*
%16 = bitcast [256 x i8*]* %8 to i8*
%17 = getelementptr inbounds [32 x i8], [32 x i8]* %9, i64 0, i64 0
%18 = getelementptr inbounds [128 x i8], [128 x i8]* %10, i64 0, i64 0
store i8 0, i8* %17
br label %19
19: ; preds = %185, %2
%20 = phi i64 [ %189, %185 ], [ 0, %2 ]
%21 = phi i32 [ 1, %185 ], [ 0, %2 ]
%22 = phi i1 [ %54, %185 ], [ false, %2 ]
%23 = phi i32 [ %43, %185 ], [ 0, %2 ]
%24 = phi i32 [ %178, %185 ], [ 0, %2 ]
br label %25
25: ; preds = %83, %19
%26 = phi i32 [ %21, %19 ], [ %84, %83 ]
%27 = phi i1 [ %22, %19 ], [ %54, %83 ]
%28 = phi i32 [ %23, %19 ], [ %43, %83 ]
%29 = phi i32 [ %24, %19 ], [ %85, %83 ]
br label %30
30: ; preds = %25, %50
%31 = phi i1 [ true, %50 ], [ %27, %25 ]
%32 = phi i32 [ %43, %50 ], [ %28, %25 ]
%33 = phi i32 [ %43, %50 ], [ %29, %25 ]
%34 = icmp eq i32 %32, %33
br i1 %34, label %38, label %35
35: ; preds = %30
%36 = add nsw i32 %32, 1
%37 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i32 %36)
br label %38
38: ; preds = %35, %30
%39 = load i32, i32* @stdin
%40 = call i32* @fgets(i8* %11, i32 1024, i32 %39)
%41 = icmp eq i32* %40, null
br i1 %41, label %191, label %42
42: ; preds = %38
%43 = add nsw i32 %32, 1
br i1 %31, label %44, label %52
44: ; preds = %42
%45 = call i64 @strncmp(i8* %11, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 6)
%46 = icmp eq i64 %45, 0
br i1 %46, label %52, label %47
47: ; preds = %44
%48 = call i64 @strncmp(i8* %11, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 5)
%49 = icmp eq i64 %48, 0
br i1 %49, label %52, label %50
50: ; preds = %47
%51 = call i32 @putchar(i32 10)
br label %30
52: ; preds = %44, %47, %42
%53 = call i64 @strncmp(i8* %11, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 15)
%54 = icmp eq i64 %53, 0
%55 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %11)
%56 = call i8* @strstr(i8* %11, i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i64 0, i64 0))
%57 = icmp eq i8* %56, null
br i1 %57, label %74, label %58
58: ; preds = %52
%59 = getelementptr inbounds i8, i8* %56, i64 12
%60 = load i8, i8* %59
%61 = icmp eq i8 %60, 40
br i1 %61, label %62, label %65
62: ; preds = %58
%63 = getelementptr inbounds i8, i8* %56, i64 13
%64 = call i32 @sscanf(i8* %63, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* %17)
br label %65
65: ; preds = %58, %62
%66 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
%67 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str.30, i64 0, i64 0))
%68 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.31, i64 0, i64 0))
%69 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([77 x i8], [77 x i8]* @str.32, i64 0, i64 0))
%70 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.12, i64 0, i64 0), i8* %17)
%71 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.33, i64 0, i64 0))
%72 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.14, i64 0, i64 0), i8* %17)
%73 = add nsw i32 %32, 8
br label %79
74: ; preds = %52
%75 = call i8* @strstr(i8* %11, i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.15, i64 0, i64 0))
%76 = icmp ne i8* %75, null
%77 = icmp eq i32 %26, 0
%78 = or i1 %76, %77
br i1 %78, label %83, label %79
79: ; preds = %65, %74
%80 = phi i32 [ %73, %65 ], [ %43, %74 ]
store i8 0, i8* %12
store i8 0, i8* %14
%81 = load i8, i8* %11
%82 = icmp eq i8 %81, 0
br i1 %82, label %83, label %86
83: ; preds = %93, %137, %79, %97, %161, %165, %168, %171, %74, %142, %146, %158
%84 = phi i32 [ 1, %158 ], [ 1, %146 ], [ 1, %142 ], [ 0, %74 ], [ 1, %171 ], [ 1, %168 ], [ 1, %165 ], [ 1, %161 ], [ 1, %97 ], [ 1, %79 ], [ 1, %137 ], [ 1, %93 ]
%85 = phi i32 [ %80, %158 ], [ %80, %146 ], [ %80, %142 ], [ %43, %74 ], [ %80, %171 ], [ %80, %168 ], [ %80, %165 ], [ %80, %161 ], [ %80, %97 ], [ %80, %79 ], [ %80, %137 ], [ %80, %93 ]
br label %25
86: ; preds = %79, %93
%87 = phi i8 [ %95, %93 ], [ %81, %79 ]
%88 = phi i8* [ %94, %93 ], [ %11, %79 ]
%89 = call i64 @isalnum(i8 signext %87)
%90 = icmp ne i64 %89, 0
%91 = icmp eq i8 %87, 95
%92 = or i1 %90, %91
br i1 %92, label %97, label %93
93: ; preds = %86
%94 = getelementptr inbounds i8, i8* %88, i64 1
%95 = load i8, i8* %94
%96 = icmp eq i8 %95, 0
br i1 %96, label %83, label %86
97: ; preds = %86
%98 = load i8, i8* %88
%99 = icmp eq i8 %98, 0
br i1 %99, label %83, label %100
100: ; preds = %97, %137
%101 = phi i8 [ %140, %137 ], [ %98, %97 ]
%102 = phi i8* [ %130, %137 ], [ %14, %97 ]
%103 = phi i8* [ %129, %137 ], [ %12, %97 ]
%104 = phi i8* [ %138, %137 ], [ %12, %97 ]
%105 = phi i8* [ %139, %137 ], [ %88, %97 ]
%106 = call i64 @isspace(i8 signext %101)
%107 = icmp eq i64 %106, 0
br i1 %107, label %108, label %117
108: ; preds = %100
%109 = call i64 @isalnum(i8 signext %101)
%110 = icmp eq i64 %109, 0
%111 = icmp ne i8 %101, 95
%112 = and i1 %110, %111
%113 = icmp ne i8 %101, 42
%114 = and i1 %112, %113
%115 = icmp eq i8 %101, 40
%116 = or i1 %114, %115
br i1 %116, label %142, label %119
117: ; preds = %100
%118 = icmp eq i8 %101, 40
br i1 %118, label %142, label %119
119: ; preds = %108, %117
%120 = call i64 @isalnum(i8 signext %101)
%121 = icmp eq i64 %120, 0
%122 = icmp ne i8 %101, 95
%123 = and i1 %121, %122
br i1 %123, label %124, label %126
124: ; preds = %119
%125 = getelementptr inbounds i8, i8* %104, i64 1
br label %128
126: ; preds = %119
%127 = getelementptr inbounds i8, i8* %102, i64 1
store i8 %101, i8* %102
br label %128
128: ; preds = %126, %124
%129 = phi i8* [ %125, %124 ], [ %103, %126 ]
%130 = phi i8* [ %14, %124 ], [ %127, %126 ]
%131 = icmp eq i8* %104, %12
br i1 %131, label %132, label %135
132: ; preds = %128
%133 = call i64 @isspace(i8 signext %101)
%134 = icmp eq i64 %133, 0
br i1 %134, label %135, label %137
135: ; preds = %132, %128
%136 = getelementptr inbounds i8, i8* %104, i64 1
store i8 %101, i8* %104
br label %137
137: ; preds = %132, %135
%138 = phi i8* [ %12, %132 ], [ %136, %135 ]
%139 = getelementptr inbounds i8, i8* %105, i64 1
%140 = load i8, i8* %139
%141 = icmp eq i8 %140, 0
br i1 %141, label %83, label %100
142: ; preds = %108, %117
%143 = icmp ne i8 %101, 40
%144 = icmp eq i8* %102, %14
%145 = select i1 %143, i1 true, i1 %144
br i1 %145, label %83, label %146
146: ; preds = %142
%147 = call i8* @strstr(i8* %105, i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%148 = icmp eq i8* %147, null
br i1 %148, label %83, label %149
149: ; preds = %146
store i8 0, i8* %104
store i8 0, i8* %103
store i8 0, i8* %102
br label %150
150: ; preds = %153, %149
%151 = phi i8* [ %103, %149 ], [ %154, %153 ]
%152 = icmp ult i8* %12, %151
br i1 %152, label %153, label %158
153: ; preds = %150
%154 = getelementptr inbounds i8, i8* %151, i64 -1
%155 = load i8, i8* %154
%156 = call i64 @isspace(i8 signext %155)
%157 = icmp eq i64 %156, 0
br i1 %157, label %158, label %150
158: ; preds = %153, %150
store i8 0, i8* %151
%159 = load i8, i8* %12
%160 = icmp eq i8 %159, 0
br i1 %160, label %83, label %161
161: ; preds = %158
%162 = call i32 @sscanf(i8* %12, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %13)
%163 = call i64 @strcmp(i8* %13, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.17, i64 0, i64 0))
%164 = icmp eq i64 %163, 0
br i1 %164, label %83, label %165
165: ; preds = %161
%166 = call i64 @strcmp(i8* %13, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.18, i64 0, i64 0))
%167 = icmp eq i64 %166, 0
br i1 %167, label %83, label %168
168: ; preds = %165
%169 = call i64 @strcmp(i8* %13, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.19, i64 0, i64 0))
%170 = icmp eq i64 %169, 0
br i1 %170, label %83, label %171
171: ; preds = %168
%172 = call i64 @strcmp(i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.20, i64 0, i64 0))
%173 = icmp eq i64 %172, 0
br i1 %173, label %83, label %174
174: ; preds = %171
%175 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.21, i64 0, i64 0), i8* %11)
%176 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.22, i64 0, i64 0), i8* %12, i8* %14, i8* %105)
%177 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.23, i64 0, i64 0), i8* %14, i8* %14)
%178 = add nsw i32 %80, 3
%179 = call i8* @strstr(i8* %11, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0))
%180 = icmp eq i8* %179, null
br i1 %180, label %185, label %181
181: ; preds = %174
store i8 0, i8* %18
%182 = getelementptr inbounds i8, i8* %179, i64 6
%183 = call i32 @sscanf(i8* %182, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* %18)
%184 = call i8* @strdup(i8* %18)
br label %185
185: ; preds = %174, %181
%186 = phi i8* [ %184, %181 ], [ null, %174 ]
%187 = getelementptr inbounds [256 x i8*], [256 x i8*]* %8, i64 0, i64 %20
store i8* %186, i8** %187
%188 = call i8* @strdup(i8* %14)
%189 = add nuw i64 %20, 1
%190 = getelementptr inbounds [256 x i8*], [256 x i8*]* %7, i64 0, i64 %20
store i8* %188, i8** %190
br label %19
191: ; preds = %38
%192 = trunc i64 %20 to i32
%193 = and i64 %20, 4294967295
%194 = getelementptr inbounds [256 x i8*], [256 x i8*]* %7, i64 0, i64 %193
store i8* null, i8** %194
%195 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.25, i64 0, i64 0), i8* %17)
%196 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.26, i64 0, i64 0), i8* %17)
%197 = icmp eq i32 %192, 0
br i1 %197, label %212, label %198
198: ; preds = %191, %209
%199 = phi i64 [ %210, %209 ], [ 0, %191 ]
%200 = getelementptr inbounds [256 x i8*], [256 x i8*]* %7, i64 0, i64 %199
%201 = load i8*, i8** %200
%202 = getelementptr inbounds [256 x i8*], [256 x i8*]* %8, i64 0, i64 %199
%203 = load i8*, i8** %202
%204 = icmp eq i8* %203, null
br i1 %204, label %207, label %205
205: ; preds = %198
%206 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.27, i64 0, i64 0), i8* %201, i8* %201, i8* %203)
br label %209
207: ; preds = %198
%208 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.28, i64 0, i64 0), i8* %201, i8* %201)
br label %209
209: ; preds = %205, %207
%210 = add nuw nsw i64 %199, 1
%211 = icmp eq i64 %210, %193
br i1 %211, label %212, label %198
212: ; preds = %209, %191
%213 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @str.34, i64 0, i64 0))
ret i32 0
}