#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 atoi(char *);
scalar_t__ malloc(int);
char *mymemchr(char *, char *, int);
int mymemcmp(char *, char *, int);
int /*<<< orphan*/ mymemcpy(char *, char *, int);
int /*<<< orphan*/ mymemmove(char *, char *, int);
int /*<<< orphan*/ mymemset(char *, char *, int);
char *mystrcat(char *, char *);
char *mystrchr(char *, char *);
int mystrcmp(char *, char *);
char *mystrcpy(char *, char *);
int mystrcspn(char *, char *);
char *mystrdup(char *);
int mystrlen(char *);
char *mystrncat(char *, char *, int);
int mystrncmp(char *, char *, int);
char *mystrncpy(char *, char *, int);
char *mystrndup(char *, int);
char *mystrpbrk(char *, char *);
char *mystrrchr(char *, char *);
int mystrspn(char *, char *);
char *mystrstr(char *, char *);
char *mystrtok(int /*<<< orphan*/ *, char *);
int /*<<< orphan*/ myswab(char *, char *, int);
int str_funcs(char *func, char *line) {
  char *str1, *str2, *delim, *str3, *str4, *token;
  int i, val;
  if (mystrcmp(func, "mymemcmp") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    delim = mystrtok(NULL, " \t");
    i = atoi(delim);
    val = mymemcmp(str1, str2, i);
    token = mystrtok(NULL, " \t\n");
    i = atoi(token);
    if (val == i)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrcmp") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    val = mystrcmp(str1, str2);
    token = mystrtok(NULL, " \t\n");
    i = atoi(token);
    if (val == i)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrncmp") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    delim = mystrtok(NULL, " \t");
    i = atoi(delim);
    val = mystrncmp(str1, str2, i);
    token = mystrtok(NULL, " \t\n");
    i = atoi(token);
    if (val == i)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrcat") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    str3 = mystrcat(str1, str2);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrncat") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    delim = mystrtok(NULL, " \t");
    i = atoi(delim);
    str3 = mystrncat(str1, str2, i);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mymemcpy") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    i = atoi(str2);
    str3 = (char *)malloc(i + 1);
    mymemcpy(str3, str1, i);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mymemmove") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    i = atoi(str2);
    str3 = (char *)malloc(i + 1);
    mymemmove(str3, str1, i);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrdup") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrdup(str1);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str2, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrndup") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    i = atoi(str2);
    str3 = mystrndup(str1, i);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrcpy") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = (char *)malloc(mystrlen(str1) + 1);
    str2 = mystrcpy(str2, str1);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str2, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrncpy") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    i = atoi(str2);
    str3 = (char *)malloc(i + 1);
    str3 = mystrncpy(str3, str1, i);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mymemchr") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    str3 = mystrtok(NULL, " \t");
    i = atoi(str3);
    str4 = mymemchr(str1, str2, i);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str4, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrchr") == 0 ||
             mystrcmp(func, "mystrrchr") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    if (mystrcmp(func, "mystrchr") == 0)
      str3 = mystrchr(str1, str2);
    else
      str3 = mystrrchr(str1, str2);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrspn") == 0 ||
             mystrcmp(func, "mystrcspn") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    if (mystrcmp(func, "mystrspn") == 0)
      i = mystrspn(str1, str2);
    else
      i = mystrcspn(str1, str2) + 1;
    token = mystrtok(NULL, " \n");
    val = atoi(token);
    if (i == val)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrpbrk") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    str3 = mystrpbrk(str1, str2);
    token = mystrtok(NULL, " \n");
    i = mystrncmp(str3, token, 1);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrstr") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    str3 = mystrstr(str1, str2);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mymemset") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    str3 = mystrtok(NULL, " \t");
    i = atoi(str3);
    mymemset(str1, str2, i);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str1, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "myswab") == 0) {
    str1 = mystrtok(NULL, " \t");
    str2 = mystrtok(NULL, " \t");
    i = atoi(str2);
    str3 = (char *)malloc(i + 1);
    myswab(str1, str3, i);
    token = mystrtok(NULL, " \n");
    i = mystrcmp(str3, token);
    if (i == 0)
      return 1;
    else
      return 0;
  } else if (mystrcmp(func, "mystrlen") == 0) {
    str1 = mystrtok(NULL, " \t");
    val = mystrlen(str1);
    token = mystrtok(NULL, " \t");
    i = atoi(token);
    if (val == i)
      return 1;
    else
      return 0;
  }
  return 2;
}


x86 assembly (clang, -O0):
<str_funcs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xd65(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1348 <str_funcs+0xc8>
xor    %eax,%eax
mov    %eax,%edi
lea    0xd55(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xd41(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xd2d(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1090 <mymemcmp@plt>
mov    %eax,-0x50(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xcfd(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jne    133c <str_funcs+0xbc>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0xcbd(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    13dd <str_funcs+0x15d>
xor    %eax,%eax
mov    %eax,%edi
lea    0xc9d(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xc89(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x50(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xc68(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jne    13d1 <str_funcs+0x151>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0xc31(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1495 <str_funcs+0x215>
xor    %eax,%eax
mov    %eax,%edi
lea    0xc08(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xbf4(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xbe0(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1160 <mystrncmp@plt>
mov    %eax,-0x50(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xbb0(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jne    1489 <str_funcs+0x209>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0xb83(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    152d <str_funcs+0x2ad>
xor    %eax,%eax
mov    %eax,%edi
lea    0xb50(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xb3c(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   10e0 <mystrcat@plt>
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xb3a(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1521 <str_funcs+0x2a1>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0xaf7(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    15e8 <str_funcs+0x368>
xor    %eax,%eax
mov    %eax,%edi
lea    0xab8(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xaa4(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xa90(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1070 <mystrncat@plt>
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xa7f(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    15dc <str_funcs+0x35c>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0xa46(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    169a <str_funcs+0x41a>
xor    %eax,%eax
mov    %eax,%edi
lea    0x9fd(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x9e9(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
add    $0x1,%edi
call   10f0 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   11a0 <mymemcpy@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0x9cd(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    168e <str_funcs+0x40e>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x99d(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    174c <str_funcs+0x4cc>
xor    %eax,%eax
mov    %eax,%edi
lea    0x94b(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x937(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
add    $0x1,%edi
call   10f0 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   10a0 <mymemmove@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0x91b(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1740 <str_funcs+0x4c0>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x8f5(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    17cc <str_funcs+0x54c>
xor    %eax,%eax
mov    %eax,%edi
lea    0x899(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
call   1080 <mystrdup@plt>
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x89b(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    17c0 <str_funcs+0x540>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x87e(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    186f <str_funcs+0x5ef>
xor    %eax,%eax
mov    %eax,%edi
lea    0x819(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x805(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x4c(%rbp),%esi
call   1170 <mystrndup@plt>
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x7f8(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1863 <str_funcs+0x5e3>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x7e5(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    190a <str_funcs+0x68a>
xor    %eax,%eax
mov    %eax,%edi
lea    0x776(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
call   1120 <mystrlen@plt>
mov    %eax,%edi
add    $0x1,%edi
call   10f0 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1140 <mystrcpy@plt>
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x75d(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    18fe <str_funcs+0x67e>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x753(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    19c0 <str_funcs+0x740>
xor    %eax,%eax
mov    %eax,%edi
lea    0x6db(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x6c7(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
add    $0x1,%edi
call   10f0 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1190 <mystrncpy@plt>
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x6a7(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    19b4 <str_funcs+0x734>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x6a7(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1a7b <str_funcs+0x7fb>
xor    %eax,%eax
mov    %eax,%edi
lea    0x625(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x611(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x5fd(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   10b0 <mymemchr@plt>
mov    %rax,-0x40(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x5ec(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1a6f <str_funcs+0x7ef>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x5f5(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
je     1aad <str_funcs+0x82d>
mov    -0x10(%rbp),%rdi
lea    0x5e5(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1b5b <str_funcs+0x8db>
xor    %eax,%eax
mov    %eax,%edi
lea    0x551(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x53d(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
lea    0x59b(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1b04 <str_funcs+0x884>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1040 <mystrchr@plt>
mov    %rax,-0x38(%rbp)
jmp    1b15 <str_funcs+0x895>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1130 <mystrrchr@plt>
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x50c(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1b4f <str_funcs+0x8cf>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x528(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
je     1b8d <str_funcs+0x90d>
mov    -0x10(%rbp),%rdi
lea    0x518(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1c3a <str_funcs+0x9ba>
xor    %eax,%eax
mov    %eax,%edi
lea    0x471(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x45d(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
lea    0x4ce(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1be3 <str_funcs+0x963>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   10d0 <mystrspn@plt>
mov    %eax,-0x4c(%rbp)
jmp    1bf6 <str_funcs+0x976>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   10c0 <mystrcspn@plt>
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x42b(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jne    1c2e <str_funcs+0x9ae>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x45c(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1cd7 <str_funcs+0xa57>
xor    %eax,%eax
mov    %eax,%edi
lea    0x3ab(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x397(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1060 <mystrpbrk@plt>
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x395(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    $0x1,%edx
call   1160 <mystrncmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1ccb <str_funcs+0xa4b>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x3c9(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1d6f <str_funcs+0xaef>
xor    %eax,%eax
mov    %eax,%edi
lea    0x30e(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x2fa(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1050 <mystrstr@plt>
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x2f8(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1d63 <str_funcs+0xae3>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x33a(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1e26 <str_funcs+0xba6>
xor    %eax,%eax
mov    %eax,%edi
lea    0x276(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x262(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x24e(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1110 <mymemset@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0x241(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1e1a <str_funcs+0xb9a>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x28c(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1ed8 <str_funcs+0xc58>
xor    %eax,%eax
mov    %eax,%edi
lea    0x1bf(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x1ab(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
add    $0x1,%edi
call   10f0 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1100 <myswab@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0x18f(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1030 <mystrcmp@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1ecc <str_funcs+0xc4c>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
mov    -0x10(%rbp),%rdi
lea    0x1e1(%rip),%rsi
call   1030 <mystrcmp@plt>
cmp    $0x0,%eax
jne    1f55 <str_funcs+0xcd5>
xor    %eax,%eax
mov    %eax,%edi
lea    0x10d(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
call   1120 <mystrlen@plt>
mov    %eax,-0x50(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xed(%rip),%rsi
call   1150 <mystrtok@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
call   1180 <atoi@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jne    1f49 <str_funcs+0xcc9>
movl   $0x1,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
movl   $0x0,-0x4(%rbp)
jmp    1fb6 <str_funcs+0xd36>
jmp    1f5a <str_funcs+0xcda>
jmp    1f5f <str_funcs+0xcdf>
jmp    1f64 <str_funcs+0xce4>
jmp    1f69 <str_funcs+0xce9>
jmp    1f6e <str_funcs+0xcee>
jmp    1f73 <str_funcs+0xcf3>
jmp    1f78 <str_funcs+0xcf8>
jmp    1f7d <str_funcs+0xcfd>
jmp    1f82 <str_funcs+0xd02>
jmp    1f87 <str_funcs+0xd07>
jmp    1f8c <str_funcs+0xd0c>
jmp    1f91 <str_funcs+0xd11>
jmp    1f96 <str_funcs+0xd16>
jmp    1f9b <str_funcs+0xd1b>
jmp    1fa0 <str_funcs+0xd20>
jmp    1fa5 <str_funcs+0xd25>
jmp    1faa <str_funcs+0xd2a>
jmp    1faf <str_funcs+0xd2f>
movl   $0x2,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<str_funcs>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rdi,%rbx
lea    0xd6f(%rip),%rsi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     14a9 <str_funcs+0x229>
lea    0xd6b(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     14eb <str_funcs+0x26b>
lea    0xd5d(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     1516 <str_funcs+0x296>
lea    0xd50(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     1579 <str_funcs+0x2f9>
lea    0xd45(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     15a4 <str_funcs+0x324>
lea    0xd38(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     15fd <str_funcs+0x37d>
lea    0xd2a(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     163f <str_funcs+0x3bf>
lea    0xd1d(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     16ac <str_funcs+0x42c>
lea    0xd0f(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     16c7 <str_funcs+0x447>
lea    0xd02(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     16fc <str_funcs+0x47c>
lea    0xcf4(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     172d <str_funcs+0x4ad>
lea    0xce7(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     17b7 <str_funcs+0x537>
lea    0xcd9(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     176f <str_funcs+0x4ef>
lea    0xccb(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     176f <str_funcs+0x4ef>
lea    0xcbe(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     17fc <str_funcs+0x57c>
lea    0xcb0(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     17fc <str_funcs+0x57c>
lea    0xca3(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     185f <str_funcs+0x5df>
lea    0xc96(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     18ae <str_funcs+0x62e>
lea    0xc88(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     18dc <str_funcs+0x65c>
lea    0xc7a(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
test   %eax,%eax
je     1921 <str_funcs+0x6a1>
lea    0xc6a(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
mov    %eax,%ecx
mov    $0x2,%eax
test   %ecx,%ecx
jne    16a1 <str_funcs+0x421>
lea    0xb91(%rip),%rbx
xor    %edi,%edi
mov    %rbx,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1120 <mystrlen@plt>
mov    %eax,%ebp
xor    %edi,%edi
mov    %rbx,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    %ecx,%ebp
jmp    169e <str_funcs+0x41e>
lea    0xb59(%rip),%r15
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r14
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   1090 <mymemcmp@plt>
jmp    1556 <str_funcs+0x2d6>
lea    0xb17(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rbx,%rdi
mov    %rax,%rsi
call   1030 <mystrcmp@plt>
jmp    1556 <str_funcs+0x2d6>
lea    0xaec(%rip),%r15
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r14
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   1160 <mystrncmp@plt>
mov    %eax,%ebx
lea    0xaad(%rip),%rsi
xor    %edi,%edi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    %ecx,%ebx
jmp    169e <str_funcs+0x41e>
lea    0xa89(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rbx,%rdi
mov    %rax,%rsi
call   10e0 <mystrcat@plt>
jmp    15e4 <str_funcs+0x364>
lea    0xa5e(%rip),%r15
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r14
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   1070 <mystrncat@plt>
mov    %rax,%rbx
lea    0xa3e(%rip),%rsi
xor    %edi,%edi
call   1150 <mystrtok@plt>
mov    %rbx,%rdi
jmp    1690 <str_funcs+0x410>
lea    0xa05(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r15
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %eax,%ebx
lea    0x1(%rbx),%edi
call   10f0 <malloc@plt>
mov    %rax,%r14
mov    %rax,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
call   11a0 <mymemcpy@plt>
jmp    167f <str_funcs+0x3ff>
lea    0x9c3(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r15
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %eax,%ebx
lea    0x1(%rbx),%edi
call   10f0 <malloc@plt>
mov    %rax,%r14
mov    %rax,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
call   10a0 <mymemmove@plt>
lea    0x9a6(%rip),%rsi
xor    %edi,%edi
call   1150 <mystrtok@plt>
mov    %r14,%rdi
mov    %rax,%rsi
call   1030 <mystrcmp@plt>
mov    %eax,%ecx
xor    %eax,%eax
test   %ecx,%ecx
sete   %al
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x956(%rip),%rsi
xor    %edi,%edi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1080 <mystrdup@plt>
jmp    15e4 <str_funcs+0x364>
lea    0x93b(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %rbx,%rdi
mov    %eax,%esi
call   1170 <mystrndup@plt>
jmp    15e4 <str_funcs+0x364>
lea    0x906(%rip),%rsi
xor    %edi,%edi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
mov    %rax,%rdi
call   1120 <mystrlen@plt>
lea    0x1(%rax),%edi
call   10f0 <malloc@plt>
mov    %rax,%rdi
mov    %rbx,%rsi
call   1140 <mystrcpy@plt>
jmp    15e4 <str_funcs+0x364>
lea    0x8d5(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r15
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %eax,%ebx
lea    0x1(%rbx),%edi
call   10f0 <malloc@plt>
mov    %rax,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
call   1190 <mystrncpy@plt>
jmp    15e4 <str_funcs+0x364>
lea    0x893(%rip),%r15
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r14
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r15
lea    0x8e4(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
mov    %r14,%rdi
mov    %r15,%rsi
test   %eax,%eax
je     1842 <str_funcs+0x5c2>
call   1130 <mystrrchr@plt>
jmp    15e4 <str_funcs+0x364>
lea    0x84b(%rip),%r15
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r14
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   10b0 <mymemchr@plt>
jmp    15e4 <str_funcs+0x364>
lea    0x806(%rip),%r15
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r14
xor    %edi,%edi
mov    %r15,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r15
lea    0x86a(%rip),%rsi
mov    %rbx,%rdi
call   1030 <mystrcmp@plt>
mov    %r14,%rdi
mov    %r15,%rsi
test   %eax,%eax
je     184c <str_funcs+0x5cc>
call   10c0 <mystrcspn@plt>
mov    %eax,%ebx
add    $0x1,%ebx
jmp    1853 <str_funcs+0x5d3>
call   1040 <mystrchr@plt>
jmp    15e4 <str_funcs+0x364>
call   10d0 <mystrspn@plt>
mov    %eax,%ebx
lea    0x7d2(%rip),%rsi
jmp    155f <str_funcs+0x2df>
lea    0x7a3(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rbx,%rdi
mov    %rax,%rsi
call   1060 <mystrpbrk@plt>
mov    %rax,%rbx
lea    0x79a(%rip),%rsi
xor    %edi,%edi
call   1150 <mystrtok@plt>
mov    %rbx,%rdi
mov    %rax,%rsi
mov    $0x1,%edx
call   1160 <mystrncmp@plt>
jmp    1698 <str_funcs+0x418>
lea    0x754(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rbx,%rdi
mov    %rax,%rsi
call   1050 <mystrstr@plt>
jmp    15e4 <str_funcs+0x364>
lea    0x726(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rbx
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r15
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %eax,%edx
call   1110 <mymemset@plt>
jmp    15e7 <str_funcs+0x367>
lea    0x6e1(%rip),%r14
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%r15
xor    %edi,%edi
mov    %r14,%rsi
call   1150 <mystrtok@plt>
mov    %rax,%rdi
call   1180 <atoi@plt>
mov    %eax,%ebx
lea    0x1(%rbx),%edi
call   10f0 <malloc@plt>
mov    %rax,%r14
mov    %r15,%rdi
mov    %rax,%rsi
mov    %ebx,%edx
call   1100 <myswab@plt>
jmp    167f <str_funcs+0x3ff>

LLVM IR (-O0):
@.str = [9 x i8] c"mymemcmp\00"
@.str.1 = [3 x i8] c" \09\00"
@.str.2 = [4 x i8] c" \09\0A\00"
@.str.3 = [9 x i8] c"mystrcmp\00"
@.str.4 = [10 x i8] c"mystrncmp\00"
@.str.5 = [9 x i8] c"mystrcat\00"
@.str.6 = [3 x i8] c" \0A\00"
@.str.7 = [10 x i8] c"mystrncat\00"
@.str.8 = [9 x i8] c"mymemcpy\00"
@.str.9 = [10 x i8] c"mymemmove\00"
@.str.10 = [9 x i8] c"mystrdup\00"
@.str.11 = [10 x i8] c"mystrndup\00"
@.str.12 = [9 x i8] c"mystrcpy\00"
@.str.13 = [10 x i8] c"mystrncpy\00"
@.str.14 = [9 x i8] c"mymemchr\00"
@.str.15 = [9 x i8] c"mystrchr\00"
@.str.16 = [10 x i8] c"mystrrchr\00"
@.str.17 = [9 x i8] c"mystrspn\00"
@.str.18 = [10 x i8] c"mystrcspn\00"
@.str.19 = [10 x i8] c"mystrpbrk\00"
@.str.20 = [9 x i8] c"mystrstr\00"
@.str.21 = [9 x i8] c"mymemset\00"
@.str.22 = [7 x i8] c"myswab\00"
@.str.23 = [9 x i8] c"mystrlen\00"
define i32 @str_funcs(i8* %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
%14 = load i8*, i8** %4
%15 = call i32 @mystrcmp(i8* %14, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%16 = icmp eq i32 %15, 0
br i1 %16, label %17, label %35
17: ; preds = %2
%18 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %18, i8** %6
%19 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %19, i8** %7
%20 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %20, i8** %8
%21 = load i8*, i8** %8
%22 = call i32 @atoi(i8* %21)
store i32 %22, i32* %12
%23 = load i8*, i8** %6
%24 = load i8*, i8** %7
%25 = load i32, i32* %12
%26 = call i32 @mymemcmp(i8* %23, i8* %24, i32 %25)
store i32 %26, i32* %13
%27 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
store i8* %27, i8** %11
%28 = load i8*, i8** %11
%29 = call i32 @atoi(i8* %28)
store i32 %29, i32* %12
%30 = load i32, i32* %13
%31 = load i32, i32* %12
%32 = icmp eq i32 %30, %31
br i1 %32, label %33, label %34
33: ; preds = %17
store i32 1, i32* %3
br label %451
34: ; preds = %17
store i32 0, i32* %3
br label %451
35: ; preds = %2
%36 = load i8*, i8** %4
%37 = call i32 @mystrcmp(i8* %36, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
%38 = icmp eq i32 %37, 0
br i1 %38, label %39, label %53
39: ; preds = %35
%40 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %40, i8** %6
%41 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %41, i8** %7
%42 = load i8*, i8** %6
%43 = load i8*, i8** %7
%44 = call i32 @mystrcmp(i8* %42, i8* %43)
store i32 %44, i32* %13
%45 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
store i8* %45, i8** %11
%46 = load i8*, i8** %11
%47 = call i32 @atoi(i8* %46)
store i32 %47, i32* %12
%48 = load i32, i32* %13
%49 = load i32, i32* %12
%50 = icmp eq i32 %48, %49
br i1 %50, label %51, label %52
51: ; preds = %39
store i32 1, i32* %3
br label %451
52: ; preds = %39
store i32 0, i32* %3
br label %451
53: ; preds = %35
%54 = load i8*, i8** %4
%55 = call i32 @mystrcmp(i8* %54, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0))
%56 = icmp eq i32 %55, 0
br i1 %56, label %57, label %75
57: ; preds = %53
%58 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %58, i8** %6
%59 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %59, i8** %7
%60 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %60, i8** %8
%61 = load i8*, i8** %8
%62 = call i32 @atoi(i8* %61)
store i32 %62, i32* %12
%63 = load i8*, i8** %6
%64 = load i8*, i8** %7
%65 = load i32, i32* %12
%66 = call i32 @mystrncmp(i8* %63, i8* %64, i32 %65)
store i32 %66, i32* %13
%67 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
store i8* %67, i8** %11
%68 = load i8*, i8** %11
%69 = call i32 @atoi(i8* %68)
store i32 %69, i32* %12
%70 = load i32, i32* %13
%71 = load i32, i32* %12
%72 = icmp eq i32 %70, %71
br i1 %72, label %73, label %74
73: ; preds = %57
store i32 1, i32* %3
br label %451
74: ; preds = %57
store i32 0, i32* %3
br label %451
75: ; preds = %53
%76 = load i8*, i8** %4
%77 = call i32 @mystrcmp(i8* %76, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%78 = icmp eq i32 %77, 0
br i1 %78, label %79, label %93
79: ; preds = %75
%80 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %80, i8** %6
%81 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %81, i8** %7
%82 = load i8*, i8** %6
%83 = load i8*, i8** %7
%84 = call i8* @mystrcat(i8* %82, i8* %83)
store i8* %84, i8** %9
%85 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %85, i8** %11
%86 = load i8*, i8** %9
%87 = load i8*, i8** %11
%88 = call i32 @mystrcmp(i8* %86, i8* %87)
store i32 %88, i32* %12
%89 = load i32, i32* %12
%90 = icmp eq i32 %89, 0
br i1 %90, label %91, label %92
91: ; preds = %79
store i32 1, i32* %3
br label %451
92: ; preds = %79
store i32 0, i32* %3
br label %451
93: ; preds = %75
%94 = load i8*, i8** %4
%95 = call i32 @mystrcmp(i8* %94, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0))
%96 = icmp eq i32 %95, 0
br i1 %96, label %97, label %115
97: ; preds = %93
%98 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %98, i8** %6
%99 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %99, i8** %7
%100 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %100, i8** %8
%101 = load i8*, i8** %8
%102 = call i32 @atoi(i8* %101)
store i32 %102, i32* %12
%103 = load i8*, i8** %6
%104 = load i8*, i8** %7
%105 = load i32, i32* %12
%106 = call i8* @mystrncat(i8* %103, i8* %104, i32 %105)
store i8* %106, i8** %9
%107 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %107, i8** %11
%108 = load i8*, i8** %9
%109 = load i8*, i8** %11
%110 = call i32 @mystrcmp(i8* %108, i8* %109)
store i32 %110, i32* %12
%111 = load i32, i32* %12
%112 = icmp eq i32 %111, 0
br i1 %112, label %113, label %114
113: ; preds = %97
store i32 1, i32* %3
br label %451
114: ; preds = %97
store i32 0, i32* %3
br label %451
115: ; preds = %93
%116 = load i8*, i8** %4
%117 = call i32 @mystrcmp(i8* %116, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i64 0, i64 0))
%118 = icmp eq i32 %117, 0
br i1 %118, label %119, label %140
119: ; preds = %115
%120 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %120, i8** %6
%121 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %121, i8** %7
%122 = load i8*, i8** %7
%123 = call i32 @atoi(i8* %122)
store i32 %123, i32* %12
%124 = load i32, i32* %12
%125 = add nsw i32 %124, 1
%126 = call i64 @malloc(i32 %125)
%127 = inttoptr i64 %126 to i8*
store i8* %127, i8** %9
%128 = load i8*, i8** %9
%129 = load i8*, i8** %6
%130 = load i32, i32* %12
%131 = call i32 @mymemcpy(i8* %128, i8* %129, i32 %130)
%132 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %132, i8** %11
%133 = load i8*, i8** %9
%134 = load i8*, i8** %11
%135 = call i32 @mystrcmp(i8* %133, i8* %134)
store i32 %135, i32* %12
%136 = load i32, i32* %12
%137 = icmp eq i32 %136, 0
br i1 %137, label %138, label %139
138: ; preds = %119
store i32 1, i32* %3
br label %451
139: ; preds = %119
store i32 0, i32* %3
br label %451
140: ; preds = %115
%141 = load i8*, i8** %4
%142 = call i32 @mystrcmp(i8* %141, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0))
%143 = icmp eq i32 %142, 0
br i1 %143, label %144, label %165
144: ; preds = %140
%145 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %145, i8** %6
%146 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %146, i8** %7
%147 = load i8*, i8** %7
%148 = call i32 @atoi(i8* %147)
store i32 %148, i32* %12
%149 = load i32, i32* %12
%150 = add nsw i32 %149, 1
%151 = call i64 @malloc(i32 %150)
%152 = inttoptr i64 %151 to i8*
store i8* %152, i8** %9
%153 = load i8*, i8** %9
%154 = load i8*, i8** %6
%155 = load i32, i32* %12
%156 = call i32 @mymemmove(i8* %153, i8* %154, i32 %155)
%157 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %157, i8** %11
%158 = load i8*, i8** %9
%159 = load i8*, i8** %11
%160 = call i32 @mystrcmp(i8* %158, i8* %159)
store i32 %160, i32* %12
%161 = load i32, i32* %12
%162 = icmp eq i32 %161, 0
br i1 %162, label %163, label %164
163: ; preds = %144
store i32 1, i32* %3
br label %451
164: ; preds = %144
store i32 0, i32* %3
br label %451
165: ; preds = %140
%166 = load i8*, i8** %4
%167 = call i32 @mystrcmp(i8* %166, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i64 0, i64 0))
%168 = icmp eq i32 %167, 0
br i1 %168, label %169, label %181
169: ; preds = %165
%170 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %170, i8** %6
%171 = load i8*, i8** %6
%172 = call i8* @mystrdup(i8* %171)
store i8* %172, i8** %7
%173 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %173, i8** %11
%174 = load i8*, i8** %7
%175 = load i8*, i8** %11
%176 = call i32 @mystrcmp(i8* %174, i8* %175)
store i32 %176, i32* %12
%177 = load i32, i32* %12
%178 = icmp eq i32 %177, 0
br i1 %178, label %179, label %180
179: ; preds = %169
store i32 1, i32* %3
br label %451
180: ; preds = %169
store i32 0, i32* %3
br label %451
181: ; preds = %165
%182 = load i8*, i8** %4
%183 = call i32 @mystrcmp(i8* %182, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0))
%184 = icmp eq i32 %183, 0
br i1 %184, label %185, label %201
185: ; preds = %181
%186 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %186, i8** %6
%187 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %187, i8** %7
%188 = load i8*, i8** %7
%189 = call i32 @atoi(i8* %188)
store i32 %189, i32* %12
%190 = load i8*, i8** %6
%191 = load i32, i32* %12
%192 = call i8* @mystrndup(i8* %190, i32 %191)
store i8* %192, i8** %9
%193 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %193, i8** %11
%194 = load i8*, i8** %9
%195 = load i8*, i8** %11
%196 = call i32 @mystrcmp(i8* %194, i8* %195)
store i32 %196, i32* %12
%197 = load i32, i32* %12
%198 = icmp eq i32 %197, 0
br i1 %198, label %199, label %200
199: ; preds = %185
store i32 1, i32* %3
br label %451
200: ; preds = %185
store i32 0, i32* %3
br label %451
201: ; preds = %181
%202 = load i8*, i8** %4
%203 = call i32 @mystrcmp(i8* %202, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i64 0, i64 0))
%204 = icmp eq i32 %203, 0
br i1 %204, label %205, label %223
205: ; preds = %201
%206 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %206, i8** %6
%207 = load i8*, i8** %6
%208 = call i32 @mystrlen(i8* %207)
%209 = add nsw i32 %208, 1
%210 = call i64 @malloc(i32 %209)
%211 = inttoptr i64 %210 to i8*
store i8* %211, i8** %7
%212 = load i8*, i8** %7
%213 = load i8*, i8** %6
%214 = call i8* @mystrcpy(i8* %212, i8* %213)
store i8* %214, i8** %7
%215 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %215, i8** %11
%216 = load i8*, i8** %7
%217 = load i8*, i8** %11
%218 = call i32 @mystrcmp(i8* %216, i8* %217)
store i32 %218, i32* %12
%219 = load i32, i32* %12
%220 = icmp eq i32 %219, 0
br i1 %220, label %221, label %222
221: ; preds = %205
store i32 1, i32* %3
br label %451
222: ; preds = %205
store i32 0, i32* %3
br label %451
223: ; preds = %201
%224 = load i8*, i8** %4
%225 = call i32 @mystrcmp(i8* %224, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%226 = icmp eq i32 %225, 0
br i1 %226, label %227, label %248
227: ; preds = %223
%228 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %228, i8** %6
%229 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %229, i8** %7
%230 = load i8*, i8** %7
%231 = call i32 @atoi(i8* %230)
store i32 %231, i32* %12
%232 = load i32, i32* %12
%233 = add nsw i32 %232, 1
%234 = call i64 @malloc(i32 %233)
%235 = inttoptr i64 %234 to i8*
store i8* %235, i8** %9
%236 = load i8*, i8** %9
%237 = load i8*, i8** %6
%238 = load i32, i32* %12
%239 = call i8* @mystrncpy(i8* %236, i8* %237, i32 %238)
store i8* %239, i8** %9
%240 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %240, i8** %11
%241 = load i8*, i8** %9
%242 = load i8*, i8** %11
%243 = call i32 @mystrcmp(i8* %241, i8* %242)
store i32 %243, i32* %12
%244 = load i32, i32* %12
%245 = icmp eq i32 %244, 0
br i1 %245, label %246, label %247
246: ; preds = %227
store i32 1, i32* %3
br label %451
247: ; preds = %227
store i32 0, i32* %3
br label %451
248: ; preds = %223
%249 = load i8*, i8** %4
%250 = call i32 @mystrcmp(i8* %249, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i64 0, i64 0))
%251 = icmp eq i32 %250, 0
br i1 %251, label %252, label %270
252: ; preds = %248
%253 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %253, i8** %6
%254 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %254, i8** %7
%255 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %255, i8** %9
%256 = load i8*, i8** %9
%257 = call i32 @atoi(i8* %256)
store i32 %257, i32* %12
%258 = load i8*, i8** %6
%259 = load i8*, i8** %7
%260 = load i32, i32* %12
%261 = call i8* @mymemchr(i8* %258, i8* %259, i32 %260)
store i8* %261, i8** %10
%262 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %262, i8** %11
%263 = load i8*, i8** %10
%264 = load i8*, i8** %11
%265 = call i32 @mystrcmp(i8* %263, i8* %264)
store i32 %265, i32* %12
%266 = load i32, i32* %12
%267 = icmp eq i32 %266, 0
br i1 %267, label %268, label %269
268: ; preds = %252
store i32 1, i32* %3
br label %451
269: ; preds = %252
store i32 0, i32* %3
br label %451
270: ; preds = %248
%271 = load i8*, i8** %4
%272 = call i32 @mystrcmp(i8* %271, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0))
%273 = icmp eq i32 %272, 0
br i1 %273, label %278, label %274
274: ; preds = %270
%275 = load i8*, i8** %4
%276 = call i32 @mystrcmp(i8* %275, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.16, i64 0, i64 0))
%277 = icmp eq i32 %276, 0
br i1 %277, label %278, label %301
278: ; preds = %274, %270
%279 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %279, i8** %6
%280 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %280, i8** %7
%281 = load i8*, i8** %4
%282 = call i32 @mystrcmp(i8* %281, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0))
%283 = icmp eq i32 %282, 0
br i1 %283, label %284, label %288
284: ; preds = %278
%285 = load i8*, i8** %6
%286 = load i8*, i8** %7
%287 = call i8* @mystrchr(i8* %285, i8* %286)
store i8* %287, i8** %9
br label %292
288: ; preds = %278
%289 = load i8*, i8** %6
%290 = load i8*, i8** %7
%291 = call i8* @mystrrchr(i8* %289, i8* %290)
store i8* %291, i8** %9
br label %292
292: ; preds = %288, %284
%293 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %293, i8** %11
%294 = load i8*, i8** %9
%295 = load i8*, i8** %11
%296 = call i32 @mystrcmp(i8* %294, i8* %295)
store i32 %296, i32* %12
%297 = load i32, i32* %12
%298 = icmp eq i32 %297, 0
br i1 %298, label %299, label %300
299: ; preds = %292
store i32 1, i32* %3
br label %451
300: ; preds = %292
store i32 0, i32* %3
br label %451
301: ; preds = %274
%302 = load i8*, i8** %4
%303 = call i32 @mystrcmp(i8* %302, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.17, i64 0, i64 0))
%304 = icmp eq i32 %303, 0
br i1 %304, label %309, label %305
305: ; preds = %301
%306 = load i8*, i8** %4
%307 = call i32 @mystrcmp(i8* %306, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.18, i64 0, i64 0))
%308 = icmp eq i32 %307, 0
br i1 %308, label %309, label %333
309: ; preds = %305, %301
%310 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %310, i8** %6
%311 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %311, i8** %7
%312 = load i8*, i8** %4
%313 = call i32 @mystrcmp(i8* %312, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.17, i64 0, i64 0))
%314 = icmp eq i32 %313, 0
br i1 %314, label %315, label %319
315: ; preds = %309
%316 = load i8*, i8** %6
%317 = load i8*, i8** %7
%318 = call i32 @mystrspn(i8* %316, i8* %317)
store i32 %318, i32* %12
br label %324
319: ; preds = %309
%320 = load i8*, i8** %6
%321 = load i8*, i8** %7
%322 = call i32 @mystrcspn(i8* %320, i8* %321)
%323 = add nsw i32 %322, 1
store i32 %323, i32* %12
br label %324
324: ; preds = %319, %315
%325 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %325, i8** %11
%326 = load i8*, i8** %11
%327 = call i32 @atoi(i8* %326)
store i32 %327, i32* %13
%328 = load i32, i32* %12
%329 = load i32, i32* %13
%330 = icmp eq i32 %328, %329
br i1 %330, label %331, label %332
331: ; preds = %324
store i32 1, i32* %3
br label %451
332: ; preds = %324
store i32 0, i32* %3
br label %451
333: ; preds = %305
%334 = load i8*, i8** %4
%335 = call i32 @mystrcmp(i8* %334, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.19, i64 0, i64 0))
%336 = icmp eq i32 %335, 0
br i1 %336, label %337, label %351
337: ; preds = %333
%338 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %338, i8** %6
%339 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %339, i8** %7
%340 = load i8*, i8** %6
%341 = load i8*, i8** %7
%342 = call i8* @mystrpbrk(i8* %340, i8* %341)
store i8* %342, i8** %9
%343 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %343, i8** %11
%344 = load i8*, i8** %9
%345 = load i8*, i8** %11
%346 = call i32 @mystrncmp(i8* %344, i8* %345, i32 1)
store i32 %346, i32* %12
%347 = load i32, i32* %12
%348 = icmp eq i32 %347, 0
br i1 %348, label %349, label %350
349: ; preds = %337
store i32 1, i32* %3
br label %451
350: ; preds = %337
store i32 0, i32* %3
br label %451
351: ; preds = %333
%352 = load i8*, i8** %4
%353 = call i32 @mystrcmp(i8* %352, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.20, i64 0, i64 0))
%354 = icmp eq i32 %353, 0
br i1 %354, label %355, label %369
355: ; preds = %351
%356 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %356, i8** %6
%357 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %357, i8** %7
%358 = load i8*, i8** %6
%359 = load i8*, i8** %7
%360 = call i8* @mystrstr(i8* %358, i8* %359)
store i8* %360, i8** %9
%361 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %361, i8** %11
%362 = load i8*, i8** %9
%363 = load i8*, i8** %11
%364 = call i32 @mystrcmp(i8* %362, i8* %363)
store i32 %364, i32* %12
%365 = load i32, i32* %12
%366 = icmp eq i32 %365, 0
br i1 %366, label %367, label %368
367: ; preds = %355
store i32 1, i32* %3
br label %451
368: ; preds = %355
store i32 0, i32* %3
br label %451
369: ; preds = %351
%370 = load i8*, i8** %4
%371 = call i32 @mystrcmp(i8* %370, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.21, i64 0, i64 0))
%372 = icmp eq i32 %371, 0
br i1 %372, label %373, label %391
373: ; preds = %369
%374 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %374, i8** %6
%375 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %375, i8** %7
%376 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %376, i8** %9
%377 = load i8*, i8** %9
%378 = call i32 @atoi(i8* %377)
store i32 %378, i32* %12
%379 = load i8*, i8** %6
%380 = load i8*, i8** %7
%381 = load i32, i32* %12
%382 = call i32 @mymemset(i8* %379, i8* %380, i32 %381)
%383 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %383, i8** %11
%384 = load i8*, i8** %6
%385 = load i8*, i8** %11
%386 = call i32 @mystrcmp(i8* %384, i8* %385)
store i32 %386, i32* %12
%387 = load i32, i32* %12
%388 = icmp eq i32 %387, 0
br i1 %388, label %389, label %390
389: ; preds = %373
store i32 1, i32* %3
br label %451
390: ; preds = %373
store i32 0, i32* %3
br label %451
391: ; preds = %369
%392 = load i8*, i8** %4
%393 = call i32 @mystrcmp(i8* %392, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i64 0, i64 0))
%394 = icmp eq i32 %393, 0
br i1 %394, label %395, label %416
395: ; preds = %391
%396 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %396, i8** %6
%397 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %397, i8** %7
%398 = load i8*, i8** %7
%399 = call i32 @atoi(i8* %398)
store i32 %399, i32* %12
%400 = load i32, i32* %12
%401 = add nsw i32 %400, 1
%402 = call i64 @malloc(i32 %401)
%403 = inttoptr i64 %402 to i8*
store i8* %403, i8** %9
%404 = load i8*, i8** %6
%405 = load i8*, i8** %9
%406 = load i32, i32* %12
%407 = call i32 @myswab(i8* %404, i8* %405, i32 %406)
%408 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i8* %408, i8** %11
%409 = load i8*, i8** %9
%410 = load i8*, i8** %11
%411 = call i32 @mystrcmp(i8* %409, i8* %410)
store i32 %411, i32* %12
%412 = load i32, i32* %12
%413 = icmp eq i32 %412, 0
br i1 %413, label %414, label %415
414: ; preds = %395
store i32 1, i32* %3
br label %451
415: ; preds = %395
store i32 0, i32* %3
br label %451
416: ; preds = %391
%417 = load i8*, i8** %4
%418 = call i32 @mystrcmp(i8* %417, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.23, i64 0, i64 0))
%419 = icmp eq i32 %418, 0
br i1 %419, label %420, label %432
420: ; preds = %416
%421 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %421, i8** %6
%422 = load i8*, i8** %6
%423 = call i32 @mystrlen(i8* %422)
store i32 %423, i32* %13
%424 = call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %424, i8** %11
%425 = load i8*, i8** %11
%426 = call i32 @atoi(i8* %425)
store i32 %426, i32* %12
%427 = load i32, i32* %13
%428 = load i32, i32* %12
%429 = icmp eq i32 %427, %428
br i1 %429, label %430, label %431
430: ; preds = %420
store i32 1, i32* %3
br label %451
431: ; preds = %420
store i32 0, i32* %3
br label %451
432: ; preds = %416
br label %433
433: ; preds = %432
br label %434
434: ; preds = %433
br label %435
435: ; preds = %434
br label %436
436: ; preds = %435
br label %437
437: ; preds = %436
br label %438
438: ; preds = %437
br label %439
439: ; preds = %438
br label %440
440: ; preds = %439
br label %441
441: ; preds = %440
br label %442
442: ; preds = %441
br label %443
443: ; preds = %442
br label %444
444: ; preds = %443
br label %445
445: ; preds = %444
br label %446
446: ; preds = %445
br label %447
447: ; preds = %446
br label %448
448: ; preds = %447
br label %449
449: ; preds = %448
br label %450
450: ; preds = %449
store i32 2, i32* %3
br label %451
451: ; preds = %450, %431, %430, %415, %414, %390, %389, %368, %367, %350, %349, %332, %331, %300, %299, %269, %268, %247, %246, %222, %221, %200, %199, %180, %179, %164, %163, %139, %138, %114, %113, %92, %91, %74, %73, %52, %51, %34, %33
%452 = load i32, i32* %3
ret i32 %452
}

LLVM IR (-O2):
@.str = [9 x i8] c"mymemcmp\00"
@.str.1 = [3 x i8] c" \09\00"
@.str.2 = [4 x i8] c" \09\0A\00"
@.str.3 = [9 x i8] c"mystrcmp\00"
@.str.4 = [10 x i8] c"mystrncmp\00"
@.str.5 = [9 x i8] c"mystrcat\00"
@.str.6 = [3 x i8] c" \0A\00"
@.str.7 = [10 x i8] c"mystrncat\00"
@.str.8 = [9 x i8] c"mymemcpy\00"
@.str.9 = [10 x i8] c"mymemmove\00"
@.str.10 = [9 x i8] c"mystrdup\00"
@.str.11 = [10 x i8] c"mystrndup\00"
@.str.12 = [9 x i8] c"mystrcpy\00"
@.str.13 = [10 x i8] c"mystrncpy\00"
@.str.14 = [9 x i8] c"mymemchr\00"
@.str.15 = [9 x i8] c"mystrchr\00"
@.str.16 = [10 x i8] c"mystrrchr\00"
@.str.17 = [9 x i8] c"mystrspn\00"
@.str.18 = [10 x i8] c"mystrcspn\00"
@.str.19 = [10 x i8] c"mystrpbrk\00"
@.str.20 = [9 x i8] c"mystrstr\00"
@.str.21 = [9 x i8] c"mymemset\00"
@.str.22 = [7 x i8] c"myswab\00"
@.str.23 = [9 x i8] c"mystrlen\00"
define i32 @str_funcs(i8* %0, i8* nocapture readnone %1) {
%3 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%4 = icmp eq i32 %3, 0
br i1 %4, label %5, label %15
5: ; preds = %2
%6 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%7 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%8 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%9 = tail call i32 @atoi(i8* %8)
%10 = tail call i32 @mymemcmp(i8* %6, i8* %7, i32 %9)
%11 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
%12 = tail call i32 @atoi(i8* %11)
%13 = icmp eq i32 %10, %12
%14 = zext i1 %13 to i32
br label %260
15: ; preds = %2
%16 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
%17 = icmp eq i32 %16, 0
br i1 %17, label %18, label %26
18: ; preds = %15
%19 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%20 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%21 = tail call i32 @mystrcmp(i8* %19, i8* %20)
%22 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
%23 = tail call i32 @atoi(i8* %22)
%24 = icmp eq i32 %21, %23
%25 = zext i1 %24 to i32
br label %260
26: ; preds = %15
%27 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0))
%28 = icmp eq i32 %27, 0
br i1 %28, label %29, label %39
29: ; preds = %26
%30 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%31 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%32 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%33 = tail call i32 @atoi(i8* %32)
%34 = tail call i32 @mystrncmp(i8* %30, i8* %31, i32 %33)
%35 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
%36 = tail call i32 @atoi(i8* %35)
%37 = icmp eq i32 %34, %36
%38 = zext i1 %37 to i32
br label %260
39: ; preds = %26
%40 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%41 = icmp eq i32 %40, 0
br i1 %41, label %42, label %50
42: ; preds = %39
%43 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%44 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%45 = tail call i8* @mystrcat(i8* %43, i8* %44)
%46 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%47 = tail call i32 @mystrcmp(i8* %45, i8* %46)
%48 = icmp eq i32 %47, 0
%49 = zext i1 %48 to i32
br label %260
50: ; preds = %39
%51 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0))
%52 = icmp eq i32 %51, 0
br i1 %52, label %53, label %63
53: ; preds = %50
%54 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%55 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%56 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%57 = tail call i32 @atoi(i8* %56)
%58 = tail call i8* @mystrncat(i8* %54, i8* %55, i32 %57)
%59 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%60 = tail call i32 @mystrcmp(i8* %58, i8* %59)
%61 = icmp eq i32 %60, 0
%62 = zext i1 %61 to i32
br label %260
63: ; preds = %50
%64 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i64 0, i64 0))
%65 = icmp eq i32 %64, 0
br i1 %65, label %66, label %78
66: ; preds = %63
%67 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%68 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%69 = tail call i32 @atoi(i8* %68)
%70 = add nsw i32 %69, 1
%71 = tail call i64 @malloc(i32 %70)
%72 = inttoptr i64 %71 to i8*
%73 = tail call i32 @mymemcpy(i8* %72, i8* %67, i32 %69)
%74 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%75 = tail call i32 @mystrcmp(i8* %72, i8* %74)
%76 = icmp eq i32 %75, 0
%77 = zext i1 %76 to i32
br label %260
78: ; preds = %63
%79 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0))
%80 = icmp eq i32 %79, 0
br i1 %80, label %81, label %93
81: ; preds = %78
%82 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%83 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%84 = tail call i32 @atoi(i8* %83)
%85 = add nsw i32 %84, 1
%86 = tail call i64 @malloc(i32 %85)
%87 = inttoptr i64 %86 to i8*
%88 = tail call i32 @mymemmove(i8* %87, i8* %82, i32 %84)
%89 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%90 = tail call i32 @mystrcmp(i8* %87, i8* %89)
%91 = icmp eq i32 %90, 0
%92 = zext i1 %91 to i32
br label %260
93: ; preds = %78
%94 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i64 0, i64 0))
%95 = icmp eq i32 %94, 0
br i1 %95, label %96, label %103
96: ; preds = %93
%97 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%98 = tail call i8* @mystrdup(i8* %97)
%99 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%100 = tail call i32 @mystrcmp(i8* %98, i8* %99)
%101 = icmp eq i32 %100, 0
%102 = zext i1 %101 to i32
br label %260
103: ; preds = %93
%104 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0))
%105 = icmp eq i32 %104, 0
br i1 %105, label %106, label %115
106: ; preds = %103
%107 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%108 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%109 = tail call i32 @atoi(i8* %108)
%110 = tail call i8* @mystrndup(i8* %107, i32 %109)
%111 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%112 = tail call i32 @mystrcmp(i8* %110, i8* %111)
%113 = icmp eq i32 %112, 0
%114 = zext i1 %113 to i32
br label %260
115: ; preds = %103
%116 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i64 0, i64 0))
%117 = icmp eq i32 %116, 0
br i1 %117, label %118, label %129
118: ; preds = %115
%119 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%120 = tail call i32 @mystrlen(i8* %119)
%121 = add nsw i32 %120, 1
%122 = tail call i64 @malloc(i32 %121)
%123 = inttoptr i64 %122 to i8*
%124 = tail call i8* @mystrcpy(i8* %123, i8* %119)
%125 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%126 = tail call i32 @mystrcmp(i8* %124, i8* %125)
%127 = icmp eq i32 %126, 0
%128 = zext i1 %127 to i32
br label %260
129: ; preds = %115
%130 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%131 = icmp eq i32 %130, 0
br i1 %131, label %132, label %144
132: ; preds = %129
%133 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%134 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%135 = tail call i32 @atoi(i8* %134)
%136 = add nsw i32 %135, 1
%137 = tail call i64 @malloc(i32 %136)
%138 = inttoptr i64 %137 to i8*
%139 = tail call i8* @mystrncpy(i8* %138, i8* %133, i32 %135)
%140 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%141 = tail call i32 @mystrcmp(i8* %139, i8* %140)
%142 = icmp eq i32 %141, 0
%143 = zext i1 %142 to i32
br label %260
144: ; preds = %129
%145 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i64 0, i64 0))
%146 = icmp eq i32 %145, 0
br i1 %146, label %147, label %157
147: ; preds = %144
%148 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%149 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%150 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%151 = tail call i32 @atoi(i8* %150)
%152 = tail call i8* @mymemchr(i8* %148, i8* %149, i32 %151)
%153 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%154 = tail call i32 @mystrcmp(i8* %152, i8* %153)
%155 = icmp eq i32 %154, 0
%156 = zext i1 %155 to i32
br label %260
157: ; preds = %144
%158 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0))
%159 = icmp eq i32 %158, 0
br i1 %159, label %163, label %160
160: ; preds = %157
%161 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.16, i64 0, i64 0))
%162 = icmp eq i32 %161, 0
br i1 %162, label %163, label %178
163: ; preds = %160, %157
%164 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%165 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%166 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0))
%167 = icmp eq i32 %166, 0
br i1 %167, label %168, label %170
168: ; preds = %163
%169 = tail call i8* @mystrchr(i8* %164, i8* %165)
br label %172
170: ; preds = %163
%171 = tail call i8* @mystrrchr(i8* %164, i8* %165)
br label %172
172: ; preds = %170, %168
%173 = phi i8* [ %169, %168 ], [ %171, %170 ]
%174 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%175 = tail call i32 @mystrcmp(i8* %173, i8* %174)
%176 = icmp eq i32 %175, 0
%177 = zext i1 %176 to i32
br label %260
178: ; preds = %160
%179 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.17, i64 0, i64 0))
%180 = icmp eq i32 %179, 0
br i1 %180, label %184, label %181
181: ; preds = %178
%182 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.18, i64 0, i64 0))
%183 = icmp eq i32 %182, 0
br i1 %183, label %184, label %200
184: ; preds = %181, %178
%185 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%186 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%187 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.17, i64 0, i64 0))
%188 = icmp eq i32 %187, 0
br i1 %188, label %189, label %191
189: ; preds = %184
%190 = tail call i32 @mystrspn(i8* %185, i8* %186)
br label %194
191: ; preds = %184
%192 = tail call i32 @mystrcspn(i8* %185, i8* %186)
%193 = add nsw i32 %192, 1
br label %194
194: ; preds = %191, %189
%195 = phi i32 [ %190, %189 ], [ %193, %191 ]
%196 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%197 = tail call i32 @atoi(i8* %196)
%198 = icmp eq i32 %195, %197
%199 = zext i1 %198 to i32
br label %260
200: ; preds = %181
%201 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.19, i64 0, i64 0))
%202 = icmp eq i32 %201, 0
br i1 %202, label %203, label %211
203: ; preds = %200
%204 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%205 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%206 = tail call i8* @mystrpbrk(i8* %204, i8* %205)
%207 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%208 = tail call i32 @mystrncmp(i8* %206, i8* %207, i32 1)
%209 = icmp eq i32 %208, 0
%210 = zext i1 %209 to i32
br label %260
211: ; preds = %200
%212 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.20, i64 0, i64 0))
%213 = icmp eq i32 %212, 0
br i1 %213, label %214, label %222
214: ; preds = %211
%215 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%216 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%217 = tail call i8* @mystrstr(i8* %215, i8* %216)
%218 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%219 = tail call i32 @mystrcmp(i8* %217, i8* %218)
%220 = icmp eq i32 %219, 0
%221 = zext i1 %220 to i32
br label %260
222: ; preds = %211
%223 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.21, i64 0, i64 0))
%224 = icmp eq i32 %223, 0
br i1 %224, label %225, label %235
225: ; preds = %222
%226 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%227 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%228 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%229 = tail call i32 @atoi(i8* %228)
%230 = tail call i32 @mymemset(i8* %226, i8* %227, i32 %229)
%231 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%232 = tail call i32 @mystrcmp(i8* %226, i8* %231)
%233 = icmp eq i32 %232, 0
%234 = zext i1 %233 to i32
br label %260
235: ; preds = %222
%236 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i64 0, i64 0))
%237 = icmp eq i32 %236, 0
br i1 %237, label %238, label %250
238: ; preds = %235
%239 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%240 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%241 = tail call i32 @atoi(i8* %240)
%242 = add nsw i32 %241, 1
%243 = tail call i64 @malloc(i32 %242)
%244 = inttoptr i64 %243 to i8*
%245 = tail call i32 @myswab(i8* %239, i8* %244, i32 %241)
%246 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%247 = tail call i32 @mystrcmp(i8* %244, i8* %246)
%248 = icmp eq i32 %247, 0
%249 = zext i1 %248 to i32
br label %260
250: ; preds = %235
%251 = tail call i32 @mystrcmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.23, i64 0, i64 0))
%252 = icmp eq i32 %251, 0
br i1 %252, label %253, label %260
253: ; preds = %250
%254 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%255 = tail call i32 @mystrlen(i8* %254)
%256 = tail call i8* @mystrtok(i32* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%257 = tail call i32 @atoi(i8* %256)
%258 = icmp eq i32 %255, %257
%259 = zext i1 %258 to i32
br label %260
260: ; preds = %250, %253, %238, %225, %214, %203, %194, %172, %147, %132, %118, %106, %96, %81, %66, %53, %42, %29, %18, %5
%261 = phi i32 [ %14, %5 ], [ %25, %18 ], [ %38, %29 ], [ %49, %42 ], [ %62, %53 ], [ %77, %66 ], [ %92, %81 ], [ %102, %96 ], [ %114, %106 ], [ %128, %118 ], [ %143, %132 ], [ %156, %147 ], [ %177, %172 ], [ %199, %194 ], [ %210, %203 ], [ %221, %214 ], [ %234, %225 ], [ %249, %238 ], [ %259, %253 ], [ 2, %250 ]
ret i32 %261
}