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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(char *);
char *malloc(int);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
int strncmp(char *, char *, int);
char *strstr(char *, char *);
int e_compstr(char *a, char *b) {
  int n, k;
  char *ctmp, *cp;
  if (a[0] == '*' && !a[1])
    return (0);
  if (!a[0] || !b[0])
    return (a[0] - b[0]);
  if (a[0] == '*' && a[1] == '*')
    return (e_compstr(++a, b));
  for (n = a[0] == '*' ? 2 : 1;
       a[n] != '*' && a[n] != '?' && a[n] != '[' && a[n]; n++)
    ;
  if (a[0] == '*') {
    n--;
    a++;
    if (a[0] == '?') {
      cp = malloc((strlen(a) + 1) * sizeof(char));
      strcpy(cp, a);
      cp[0] = '*';
      n = e_compstr(cp, ++b);
      free(cp);
      return (n);
    } else if (a[0] == '[') {
      while (*b && (n = e_compstr(a, b)))
        b++;
      return (n);
    }
    ctmp = malloc(n + 1);
    for (k = 0; k < n; k++)
      ctmp[k] = a[k];
    ctmp[n] = '\0';
    cp = strstr(b, ctmp);
    free(ctmp);
    if (cp == NULL)
      return ((a[0] - b[0]) ? a[0] - b[0] : -1);
    if (!a[n] && !cp[n])
      return (0);
    if (!a[n])
      return (e_compstr(a - 1, cp + 1));
    if (!(k = e_compstr(a + n, cp + n)))
      return (0);
    return (e_compstr(a - 1, cp + 1));
  } else if (a[0] == '?') {
    n--;
    a++;
    b++;
  } else if (a[0] == '[') {
    if (a[1] == '!') {
      for (k = 2; a[k] && (a[k] != ']' || k == 2) && a[k] != b[0]; k++)
        if (a[k + 1] == '-' && b[0] >= a[k] && b[0] <= a[k + 2])
          return (-b[0]);
      if (a[k] != ']')
        return (-b[0]);
      n -= (k + 1);
      a += (k + 1);
      b++;
    } else {
      for (k = 1; a[k] && (a[k] != ']' || k == 1) && a[k] != b[0]; k++)
        if (a[k + 1] == '-' && b[0] >= a[k] && b[0] <= a[k + 2])
          break;
      if (a[k] == ']' || a[k] == '\0')
        return (-b[0]);
      for (; a[k] && (a[k] != ']'); k++)
        ;
      n -= (k + 1);
      a += (k + 1);
      b++;
    }
  }
  if (n <= 0)
    return (e_compstr(a, b));
  if ((k = strncmp(a, b, n)) != 0)
    return (k);
  return (e_compstr(a + n, b + n));
}


x86 assembly (clang, -O0):
<e_compstr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    11aa <e_compstr+0x3a>
mov    -0x10(%rbp),%rax
cmpb   $0x0,0x1(%rax)
jne    11aa <e_compstr+0x3a>
movl   $0x0,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     11c4 <e_compstr+0x54>
mov    -0x18(%rbp),%rax
cmpb   $0x0,(%rax)
jne    11dc <e_compstr+0x6c>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    121a <e_compstr+0xaa>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2a,%eax
jne    121a <e_compstr+0xaa>
mov    -0x10(%rbp),%rdi
add    $0x1,%rdi
mov    %rdi,-0x10(%rbp)
mov    -0x18(%rbp),%rsi
call   1070 <e_compstr@plt>
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edx
mov    $0x1,%eax
mov    $0x2,%ecx
cmp    $0x2a,%edx
cmove  %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2a,%ecx
mov    %al,-0x31(%rbp)
je     1297 <e_compstr+0x127>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x3f,%ecx
mov    %al,-0x31(%rbp)
je     1297 <e_compstr+0x127>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x5b,%ecx
mov    %al,-0x31(%rbp)
je     1297 <e_compstr+0x127>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    12a7 <e_compstr+0x137>
jmp    12ba <e_compstr+0x14a>
jmp    12ac <e_compstr+0x13c>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1234 <e_compstr+0xc4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    152f <e_compstr+0x3bf>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3f,%eax
jne    134c <e_compstr+0x1dc>
mov    -0x10(%rbp),%rdi
call   1060 <strlen@plt>
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1050 <strcpy@plt>
mov    -0x30(%rbp),%rax
movb   $0x2a,(%rax)
mov    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rsi
add    $0x1,%rsi
mov    %rsi,-0x18(%rbp)
call   1070 <e_compstr@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5b,%eax
jne    13bb <e_compstr+0x24b>
jmp    1361 <e_compstr+0x1f1>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x32(%rbp)
je     138f <e_compstr+0x21f>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1070 <e_compstr@plt>
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
setne  %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    139f <e_compstr+0x22f>
jmp    13b0 <e_compstr+0x240>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1361 <e_compstr+0x1f1>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
jmp    13c0 <e_compstr+0x250>
mov    -0x1c(%rbp),%edi
add    $0x1,%edi
call   1080 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1406 <e_compstr+0x296>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13d6 <e_compstr+0x266>
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x30(%rbp)
jne    1480 <e_compstr+0x310>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
je     1468 <e_compstr+0x2f8>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
jmp    1475 <e_compstr+0x305>
mov    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1475 <e_compstr+0x305>
mov    -0x38(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    14b0 <e_compstr+0x340>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    14b0 <e_compstr+0x340>
movl   $0x0,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    14df <e_compstr+0x36f>
mov    -0x10(%rbp),%rdi
add    $0xffffffffffffffff,%rdi
mov    -0x30(%rbp),%rsi
add    $0x1,%rsi
call   1070 <e_compstr@plt>
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
movslq -0x1c(%rbp),%rax
add    %rax,%rsi
call   1070 <e_compstr@plt>
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
jne    1512 <e_compstr+0x3a2>
movl   $0x0,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rdi
add    $0xffffffffffffffff,%rdi
mov    -0x30(%rbp),%rsi
add    $0x1,%rsi
call   1070 <e_compstr@plt>
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3f,%eax
jne    1565 <e_compstr+0x3f5>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1875 <e_compstr+0x705>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5b,%eax
jne    1870 <e_compstr+0x700>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x21,%eax
jne    16cc <e_compstr+0x55c>
movl   $0x2,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x39(%rbp)
je     15e6 <e_compstr+0x476>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
jne    15cb <e_compstr+0x45b>
xor    %eax,%eax
cmpl   $0x2,-0x20(%rbp)
mov    %al,-0x39(%rbp)
jne    15e6 <e_compstr+0x476>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    15f6 <e_compstr+0x486>
jmp    1671 <e_compstr+0x501>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    165e <e_compstr+0x4ee>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jl     165e <e_compstr+0x4ee>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     165e <e_compstr+0x4ee>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
jmp    1663 <e_compstr+0x4f3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    158d <e_compstr+0x41d>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
je     1699 <e_compstr+0x529>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    186b <e_compstr+0x6fb>
movl   $0x1,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x3a(%rbp)
je     172c <e_compstr+0x5bc>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
jne    1711 <e_compstr+0x5a1>
xor    %eax,%eax
cmpl   $0x1,-0x20(%rbp)
mov    %al,-0x3a(%rbp)
jne    172c <e_compstr+0x5bc>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
test   $0x1,%al
jne    173c <e_compstr+0x5cc>
jmp    17a9 <e_compstr+0x639>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1796 <e_compstr+0x626>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jl     1796 <e_compstr+0x626>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     1796 <e_compstr+0x626>
jmp    17a9 <e_compstr+0x639>
jmp    179b <e_compstr+0x62b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    16d3 <e_compstr+0x563>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
je     17d3 <e_compstr+0x663>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    17e6 <e_compstr+0x676>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
jmp    17eb <e_compstr+0x67b>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x3b(%rbp)
je     181a <e_compstr+0x6aa>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
setne  %al
mov    %al,-0x3b(%rbp)
mov    -0x3b(%rbp),%al
test   $0x1,%al
jne    182a <e_compstr+0x6ba>
jmp    183d <e_compstr+0x6cd>
jmp    182f <e_compstr+0x6bf>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    17eb <e_compstr+0x67b>
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1870 <e_compstr+0x700>
jmp    1875 <e_compstr+0x705>
jmp    187a <e_compstr+0x70a>
cmpl   $0x0,-0x1c(%rbp)
jg     1899 <e_compstr+0x729>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1070 <e_compstr@plt>
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1040 <strncmp@plt>
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
je     18c0 <e_compstr+0x750>
mov    -0x20(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    18de <e_compstr+0x76e>
mov    -0x10(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rsi
movslq -0x1c(%rbp),%rax
add    %rax,%rsi
call   1070 <e_compstr@plt>
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<e_compstr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r14
mov    %rdi,%r13
movabs $0x2000000200001,%rsi
lea    0x1(%r13),%rdi
lea    0x2(%r13),%rax
mov    %rax,0x20(%rsp)
mov    %rdi,0x8(%rsp)
jmp    11c7 <e_compstr+0x57>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0x0,(%rsi)
je     1710 <e_compstr+0x5a0>
add    $0x1,%r14
movabs $0x2000000200001,%rsi
movsbl 0x0(%r13),%r12d
cmp    $0x2a,%r12d
je     11f0 <e_compstr+0x80>
test   %r12b,%r12b
je     172b <e_compstr+0x5bb>
mov    (%r14),%dl
mov    $0x1,%ebp
test   %dl,%dl
jne    1212 <e_compstr+0xa2>
jmp    1696 <e_compstr+0x526>
nopl   0x0(%rax)
mov    (%rdi),%al
test   %al,%al
je     1710 <e_compstr+0x5a0>
mov    (%r14),%dl
test   %dl,%dl
je     1696 <e_compstr+0x526>
mov    $0x2,%ebp
cmp    $0x2a,%al
je     15b4 <e_compstr+0x444>
mov    %r14,0x10(%rsp)
lea    -0x1(%rbp),%r14d
lea    0x3(%rbp),%r15d
lea    -0x2(%rbp),%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x0(%r13,%rbp,1),%eax
lea    -0x2a(%rax),%ecx
cmp    $0x31,%cl
ja     1247 <e_compstr+0xd7>
movzbl %cl,%ecx
bt     %rcx,%rsi
jb     1260 <e_compstr+0xf0>
test   %al,%al
je     1260 <e_compstr+0xf0>
add    $0x1,%rbp
add    $0x1,%r14d
add    $0x1,%r15b
add    $0x1,%ebx
jmp    1230 <e_compstr+0xc0>
nopl   0x0(%rax)
cmp    $0x2a,%r12b
jne    1520 <e_compstr+0x3b0>
movsbl (%rdi),%eax
cmp    $0x3f,%eax
je     169d <e_compstr+0x52d>
lea    -0x1(%rbp),%r12d
cmp    $0x5b,%al
je     16dd <e_compstr+0x56d>
mov    %eax,0x1c(%rsp)
mov    %dl,0x7(%rsp)
mov    %ebp,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
cmp    $0x2,%ebp
jb     14c0 <e_compstr+0x350>
mov    0x1c(%rsp),%eax
mov    %al,(%rbx)
cmp    $0x1,%r12d
je     14c0 <e_compstr+0x350>
mov    %r12d,%r10d
lea    -0x1(%r10),%r9
mov    $0x1,%esi
cmp    $0x8,%r9
jb     1444 <e_compstr+0x2d4>
lea    0x1(%rbx),%rcx
mov    0x8(%rsp),%rax
lea    (%rax,%r10,1),%rdi
cmp    %rdi,%rcx
jae    12e6 <e_compstr+0x176>
mov    %rbx,%rcx
add    %r10,%rcx
cmp    %rcx,0x20(%rsp)
jb     1444 <e_compstr+0x2d4>
cmp    $0x20,%r9
jae    12f3 <e_compstr+0x183>
xor    %ecx,%ecx
jmp    1402 <e_compstr+0x292>
mov    %r9,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rsi
mov    %rsi,%r8
shr    $0x5,%r8
add    $0x1,%r8
cmp    $0x60,%rsi
jae    131b <e_compstr+0x1ab>
xor    %esi,%esi
mov    0x8(%rsp),%rax
jmp    13a2 <e_compstr+0x232>
mov    %r14d,%edi
add    $0xffffffffffffffff,%rdi
and    $0xffffffffffffffe0,%rdi
add    $0xffffffffffffffe0,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
mov    0x8(%rsp),%rax
nopl   (%rax)
movups 0x2(%r13,%rsi,1),%xmm0
movups 0x12(%r13,%rsi,1),%xmm1
movups %xmm0,0x1(%rbx,%rsi,1)
movups %xmm1,0x11(%rbx,%rsi,1)
movups 0x22(%r13,%rsi,1),%xmm0
movups 0x32(%r13,%rsi,1),%xmm1
movups %xmm0,0x21(%rbx,%rsi,1)
movups %xmm1,0x31(%rbx,%rsi,1)
movups 0x42(%r13,%rsi,1),%xmm0
movups 0x52(%r13,%rsi,1),%xmm1
movups %xmm0,0x41(%rbx,%rsi,1)
movups %xmm1,0x51(%rbx,%rsi,1)
movups 0x62(%r13,%rsi,1),%xmm0
movups 0x72(%r13,%rsi,1),%xmm1
movups %xmm0,0x61(%rbx,%rsi,1)
movups %xmm1,0x71(%rbx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1340 <e_compstr+0x1d0>
test   $0x3,%r8b
je     13f3 <e_compstr+0x283>
lea    -0x1(%r14),%edi
and    $0x60,%dil
add    $0xe0,%dil
shr    $0x5,%dil
add    $0x1,%dil
movzbl %dil,%edi
and    $0x3,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rsi,%rdx
or     $0x1,%rdx
movups (%rax,%rdx,1),%xmm0
movups 0x10(%rax,%rdx,1),%xmm1
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,0x10(%rbx,%rdx,1)
add    $0x20,%rsi
add    $0xffffffffffffffff,%rdi
jne    13d0 <e_compstr+0x260>
cmp    %rcx,%r9
je     14c0 <e_compstr+0x350>
test   $0x18,%r9b
je     143d <e_compstr+0x2cd>
add    $0xffffffff,%ebp
add    $0xffffffffffffffff,%rbp
mov    %rbp,%r8
and    $0xfffffffffffffff8,%r8
lea    0x1(%r8),%rsi
mov    %r14d,%edi
add    $0xffffffffffffffff,%rdi
and    $0xfffffffffffffff8,%rdi
nop
mov    0x2(%r13,%rcx,1),%rdx
mov    %rdx,0x1(%rbx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdi
jne    1420 <e_compstr+0x2b0>
cmp    %r8,%rbp
jne    1444 <e_compstr+0x2d4>
jmp    14c0 <e_compstr+0x350>
or     $0x1,%rcx
mov    %rcx,%rsi
mov    %r10d,%edx
sub    %esi,%edx
mov    %rsi,%rcx
not    %rcx
add    %r10,%rcx
test   $0x3,%dl
je     1481 <e_compstr+0x311>
sub    %sil,%r15b
movzbl %r15b,%eax
and    $0x3,%eax
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%edx
mov    %dl,(%rbx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1470 <e_compstr+0x300>
cmp    $0x3,%rcx
jb     14c0 <e_compstr+0x350>
mov    %r14d,%eax
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%r13,%rsi,1),%ecx
mov    %cl,(%rbx,%rsi,1)
movzbl 0x2(%r13,%rsi,1),%ecx
mov    %cl,0x1(%rbx,%rsi,1)
movzbl 0x3(%r13,%rsi,1),%ecx
mov    %cl,0x2(%rbx,%rsi,1)
movzbl 0x4(%r13,%rsi,1),%ecx
mov    %cl,0x3(%rbx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    1490 <e_compstr+0x320>
movslq %r12d,%rbp
movb   $0x0,(%rbx,%rbp,1)
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
call   1090 <strstr@plt>
mov    %rax,%r14
mov    %rbx,%rdi
call   1030 <free@plt>
test   %r14,%r14
je     1715 <e_compstr+0x5a5>
lea    (%r14,%rbp,1),%rsi
mov    0x8(%rsp),%rdi
cmpb   $0x0,(%rdi,%rbp,1)
je     11b0 <e_compstr+0x40>
add    %rdi,%rbp
mov    %rbp,%rdi
call   1070 <e_compstr@plt>
mov    0x8(%rsp),%rdi
test   %eax,%eax
jne    11b9 <e_compstr+0x49>
jmp    1710 <e_compstr+0x5a0>
nopl   0x0(%rax,%rax,1)
cmp    $0x3f,%r12b
je     15a5 <e_compstr+0x435>
cmp    $0x5b,%r12b
mov    0x10(%rsp),%r14
jne    1671 <e_compstr+0x501>
mov    (%rdi),%dil
cmp    $0x21,%dil
je     15bc <e_compstr+0x44c>
test   %dil,%dil
je     1734 <e_compstr+0x5c4>
mov    $0x1,%ebp
mov    $0x2,%esi
mov    $0x1,%ecx
jmp    1576 <e_compstr+0x406>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x1,%esi
add    $0xffffffff,%ebx
add    $0x1,%ecx
test   %dil,%dil
je     1734 <e_compstr+0x5c4>
mov    %edi,%eax
cmp    $0x5d,%dil
jne    1588 <e_compstr+0x418>
cmp    $0x1,%rbp
jne    1734 <e_compstr+0x5c4>
cmp    %dl,%al
je     1608 <e_compstr+0x498>
movzbl 0x1(%r13,%rbp,1),%edi
cmp    $0x2d,%dil
jne    1560 <e_compstr+0x3f0>
cmp    %al,%dl
jl     1560 <e_compstr+0x3f0>
cmp    0x2(%r13,%rbp,1),%dl
jg     1560 <e_compstr+0x3f0>
jmp    160a <e_compstr+0x49a>
add    $0xffffffff,%ebp
mov    %ebp,%ebx
mov    0x10(%rsp),%r14
jmp    1661 <e_compstr+0x4f1>
mov    %rdi,%r13
jmp    118e <e_compstr+0x1e>
mov    0x2(%r13),%bl
test   %bl,%bl
je     1734 <e_compstr+0x5c4>
mov    $0x3,%eax
jmp    15dc <e_compstr+0x46c>
nop
add    $0x1,%rax
test   %bl,%bl
je     1734 <e_compstr+0x5c4>
mov    %ebx,%ecx
cmp    $0x5d,%bl
jne    15e9 <e_compstr+0x479>
cmp    $0x3,%rax
jne    1655 <e_compstr+0x4e5>
cmp    %dl,%cl
je     164c <e_compstr+0x4dc>
movzbl 0x0(%r13,%rax,1),%ebx
cmp    $0x2d,%bl
jne    15d0 <e_compstr+0x460>
cmp    %cl,%dl
jl     15d0 <e_compstr+0x460>
cmp    0x1(%r13,%rax,1),%dl
jg     15d0 <e_compstr+0x460>
jmp    1734 <e_compstr+0x5c4>
mov    %edx,%eax
cmp    $0x5d,%al
je     1734 <e_compstr+0x5c4>
mov    %ecx,%eax
add    %r13,%rax
nopw   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
test   %cl,%cl
je     1638 <e_compstr+0x4c8>
cmp    $0x5d,%cl
je     1638 <e_compstr+0x4c8>
add    $0x1,%esi
add    $0xffffffff,%ebx
add    $0x1,%rax
jmp    1620 <e_compstr+0x4b0>
mov    %esi,%eax
add    %rax,%r13
mov    %r13,%rdi
movabs $0x2000000200001,%rsi
jmp    1661 <e_compstr+0x4f1>
cmp    $0x5d,%dl
jne    1734 <e_compstr+0x5c4>
sub    %eax,%ebp
mov    %eax,%eax
add    %rax,%r13
mov    %r13,%rdi
mov    %ebp,%ebx
add    $0x1,%r14
mov    %rdi,%r13
test   %ebx,%ebx
jg     1673 <e_compstr+0x503>
jmp    118e <e_compstr+0x1e>
mov    %ebp,%ebx
mov    %r13,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
jne    174d <e_compstr+0x5dd>
movslq %ebx,%rax
add    %rax,%r13
add    %rax,%r14
jmp    1184 <e_compstr+0x14>
xor    %eax,%eax
jmp    172f <e_compstr+0x5bf>
mov    %rdi,%rbp
call   1060 <strlen@plt>
lea    0x1(%rax),%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
mov    %rbp,%rsi
call   1050 <strcpy@plt>
movb   $0x2a,(%rbx)
mov    0x10(%rsp),%rsi
add    $0x1,%rsi
mov    %rbx,%rdi
call   1070 <e_compstr@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
jmp    173e <e_compstr+0x5ce>
test   %dl,%dl
je     173b <e_compstr+0x5cb>
mov    0x10(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rsi
call   1070 <e_compstr@plt>
test   %eax,%eax
je     1710 <e_compstr+0x5a0>
mov    %eax,%r12d
cmpb   $0x0,0x1(%rbx)
lea    0x1(%rbx),%rbx
mov    0x8(%rsp),%rdi
jne    16f0 <e_compstr+0x580>
jmp    173b <e_compstr+0x5cb>
xor    %r12d,%r12d
jmp    173b <e_compstr+0x5cb>
movsbl 0x7(%rsp),%eax
mov    0x1c(%rsp),%ecx
sub    %eax,%ecx
cmp    $0x1,%ecx
sbb    %r12d,%r12d
or     %ecx,%r12d
jmp    173b <e_compstr+0x5cb>
movsbl (%r14),%eax
sub    %eax,%r12d
jmp    173b <e_compstr+0x5cb>
movsbl %dl,%r12d
neg    %r12d
mov    %r12d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%r12d
jmp    173b <e_compstr+0x5cb>

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

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