#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 e_p_konv_mess(char *, char *, char *, char *, char *, int *, int *);
int /*<<< orphan*/ free(char *);
char *malloc(int);
int strlen(char *);
int strncmp(char *, char *, int);
char *strstr(char *, char *);
int e_p_comp_mess(char *a, char *b, char *c, char *txt, char *file, char *cmp,
                  int *y, int *x) {
  int i, n, k = 0, bsl = 0;
  char *ctmp, *cp, *var = NULL, *str = NULL;
  if (c > b)
    return (0);
  if (a[0] == '*' && !a[1])
    return (2);
  if (!a[0] && !b[0])
    return (2);
  if (!a[0] || !b[0])
    return (0);
  if (a[0] == '*' && (a[1] == '*' || a[1] == '$'))
    return (e_p_comp_mess(++a, b, c, txt, file, cmp, y, x));
  if (a[0] == '$' && a[1] == '{') {
    for (k = 2; a[k] && a[k] != '}'; k++)
      ;
    var = malloc((k - 1) * sizeof(char));
    for (i = 2; i < k; i++)
      var[i - 2] = a[i];
    var[k - 2] = '\0';
    if (a[k])
      k++;
    if (!a[k])
      return (!e_p_konv_mess(var, b, txt, file, cmp, y, x));
    n = a[k] == '\\' ? k : k + 1;
  } else if (a[0] == '*' && a[1] != '\\') {
    k = 1;
    n = 2;
  } else
    n = 1;
  for (; bsl || (a[n] && a[n] != '*' && a[n] != '?' && a[n] != '[' &&
                 (a[n] != '$' || a[n + 1] != '{'));
       n++)
    bsl = a[n] == '\\' ? !bsl : 0;
  if (a[0] == '*' || a[0] == '$') {
    if (a[k] == '?') {
      cp = malloc((strlen(a) + 1) * sizeof(char));
      for (i = 0; i < k && (cp[i] = a[i]); i++)
        ;
      for (i++; (cp[i - 1] = a[i]) != '\0'; i++)
        ;
      free(var);
      n = e_p_comp_mess(cp, ++b, ++c, txt, file, cmp, y, x);
      free(cp);
      return (n);
    }
    if (a[k] == '[') {
      for (i = 0; b[i] && !(n = e_p_comp_mess(a + k, b + i, c + i, txt, file,
                                              cmp, y, x));
           i++)
        ;
      if (!b[i])
        return (0);
      if (a[0] == '$') {
        str = malloc((i + 1) * sizeof(char));
        for (k = 0; k < i; k++)
          str[k] = b[k];
        str[i] = '\0';
        e_p_konv_mess(var, str, txt, file, cmp, y, x);
        free(var);
        free(str);
      }
      return (n);
    }
    n -= k;
    ctmp = malloc(n + 1);
    for (i = 0; i < n; i++)
      ctmp[i] = a[i + k];
    ctmp[n] = '\0';
    cp = strstr(b, ctmp);
    free(ctmp);
    if (cp == NULL)
      return (0);
    if (a[0] == '$') {
      for (i = 0; c + i < cp; i++)
        ;
      str = malloc((i + 1) * sizeof(char));
      for (i = 0; c + i < cp; i++)
        str[i] = c[i];
      str[i] = '\0';
      i = e_p_konv_mess(var, str, txt, file, cmp, y, x);
      free(var);
      free(str);
      if (i)
        return (0);
    }
    if (!a[k + n] && !cp[n])
      return (2);
    if (!a[k + n])
      return (e_p_comp_mess(a, cp + 1, cp + 1, txt, file, cmp, y, x));
    if ((i = e_p_comp_mess(a + k + n, cp + n, cp + n, txt, file, cmp, y, x)))
      return (i);
    if (file[0] && *y > -1)
      return (0);
    return (e_p_comp_mess(a, cp + 1, a[0] == '$' ? c : cp + 1, txt, file, cmp,
                          y, x));
  } 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 (0);
      for (; a[k] && (a[k] != ']'); k++)
        ;
      n -= (k + 1);
      a += (k + 1);
      b++;
    }
  }
  if (n <= 0)
    return (e_p_comp_mess(a, b, c, txt, file, cmp, y, x));
  if ((k = strncmp(a, b, n)) != 0)
    return (0);
  return (e_p_comp_mess(a + n, b + n, c + n, txt, file, cmp, y, x));
}


x86 assembly (clang, -O0):
<e_p_comp_mess>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movq   $0x0,-0x60(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jbe    11d3 <e_p_comp_mess+0x63>
movl   $0x0,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    11fd <e_p_comp_mess+0x8d>
mov    -0x10(%rbp),%rax
cmpb   $0x0,0x1(%rax)
jne    11fd <e_p_comp_mess+0x8d>
movl   $0x2,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1223 <e_p_comp_mess+0xb3>
mov    -0x18(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1223 <e_p_comp_mess+0xb3>
movl   $0x2,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     123d <e_p_comp_mess+0xcd>
mov    -0x18(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1249 <e_p_comp_mess+0xd9>
movl   $0x0,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    12b9 <e_p_comp_mess+0x149>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2a,%eax
je     127b <e_p_comp_mess+0x10b>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x24,%eax
jne    12b9 <e_p_comp_mess+0x149>
mov    -0x10(%rbp),%rdi
add    $0x1,%rdi
mov    %rdi,-0x10(%rbp)
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%r10
mov    0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <e_p_comp_mess@plt>
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x24,%eax
jne    1432 <e_p_comp_mess+0x2c2>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x7b,%eax
jne    1432 <e_p_comp_mess+0x2c2>
movl   $0x2,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x69(%rbp)
je     1310 <e_p_comp_mess+0x1a0>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7d,%eax
setne  %al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
test   $0x1,%al
jne    1320 <e_p_comp_mess+0x1b0>
jmp    1333 <e_p_comp_mess+0x1c3>
jmp    1325 <e_p_comp_mess+0x1b5>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12e1 <e_p_comp_mess+0x171>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x2,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1386 <e_p_comp_mess+0x216>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x60(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1351 <e_p_comp_mess+0x1e1>
mov    -0x60(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     13b2 <e_p_comp_mess+0x242>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    13fe <e_p_comp_mess+0x28e>
mov    -0x60(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
mov    0x10(%rbp),%r9
mov    0x18(%rbp),%rax
mov    %rax,(%rsp)
call   1080 <e_p_konv_mess@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
jne    141e <e_p_comp_mess+0x2ae>
mov    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    1427 <e_p_comp_mess+0x2b7>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    1472 <e_p_comp_mess+0x302>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    1466 <e_p_comp_mess+0x2f6>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x5c,%eax
je     1466 <e_p_comp_mess+0x2f6>
movl   $0x1,-0x44(%rbp)
movl   $0x2,-0x40(%rbp)
jmp    146d <e_p_comp_mess+0x2fd>
movl   $0x1,-0x40(%rbp)
jmp    1472 <e_p_comp_mess+0x302>
jmp    1477 <e_p_comp_mess+0x307>
mov    $0x1,%al
cmpl   $0x0,-0x48(%rbp)
mov    %al,-0x71(%rbp)
jne    152e <e_p_comp_mess+0x3be>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x72(%rbp)
je     1528 <e_p_comp_mess+0x3b8>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2a,%ecx
mov    %al,-0x72(%rbp)
je     1528 <e_p_comp_mess+0x3b8>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x3f,%ecx
mov    %al,-0x72(%rbp)
je     1528 <e_p_comp_mess+0x3b8>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x5b,%ecx
mov    %al,-0x72(%rbp)
je     1528 <e_p_comp_mess+0x3b8>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x24,%ecx
mov    %al,-0x73(%rbp)
jne    1522 <e_p_comp_mess+0x3b2>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7b,%eax
setne  %al
mov    %al,-0x73(%rbp)
mov    -0x73(%rbp),%al
mov    %al,-0x72(%rbp)
mov    -0x72(%rbp),%al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
test   $0x1,%al
jne    153e <e_p_comp_mess+0x3ce>
jmp    1587 <e_p_comp_mess+0x417>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
jne    1569 <e_p_comp_mess+0x3f9>
cmpl   $0x0,-0x48(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x78(%rbp)
jmp    1573 <e_p_comp_mess+0x403>
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    1573 <e_p_comp_mess+0x403>
mov    -0x78(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1477 <e_p_comp_mess+0x307>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
je     15a7 <e_p_comp_mess+0x437>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x24,%eax
jne    1b71 <e_p_comp_mess+0xa01>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3f,%eax
jne    16d7 <e_p_comp_mess+0x567>
mov    -0x10(%rbp),%rdi
call   1050 <strlen@plt>
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x44(%rbp),%ecx
mov    %al,-0x79(%rbp)
jge    1613 <e_p_comp_mess+0x4a3>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    -0x58(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    1623 <e_p_comp_mess+0x4b3>
jmp    1636 <e_p_comp_mess+0x4c6>
jmp    1628 <e_p_comp_mess+0x4b8>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15e0 <e_p_comp_mess+0x470>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    -0x58(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
cmp    $0x0,%eax
je     1679 <e_p_comp_mess+0x509>
jmp    166b <e_p_comp_mess+0x4fb>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    163f <e_p_comp_mess+0x4cf>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
mov    -0x18(%rbp),%rsi
add    $0x1,%rsi
mov    %rsi,-0x18(%rbp)
mov    -0x20(%rbp),%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%r10
mov    0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <e_p_comp_mess@plt>
mov    %eax,-0x40(%rbp)
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5b,%eax
jne    184b <e_p_comp_mess+0x6db>
movl   $0x0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x7a(%rbp)
je     175e <e_p_comp_mess+0x5ee>
mov    -0x10(%rbp),%rdi
movslq -0x44(%rbp),%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rsi
movslq -0x3c(%rbp),%rax
add    %rax,%rsi
mov    -0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rax
add    %rax,%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%r10
mov    0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <e_p_comp_mess@plt>
mov    %eax,-0x40(%rbp)
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
mov    %al,-0x7a(%rbp)
mov    -0x7a(%rbp),%al
test   $0x1,%al
jne    176e <e_p_comp_mess+0x5fe>
jmp    1781 <e_p_comp_mess+0x611>
jmp    1773 <e_p_comp_mess+0x603>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16f3 <e_p_comp_mess+0x583>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    179f <e_p_comp_mess+0x62f>
movl   $0x0,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x24,%eax
jne    1840 <e_p_comp_mess+0x6d0>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    17fd <e_p_comp_mess+0x68d>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17cd <e_p_comp_mess+0x65d>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
mov    0x10(%rbp),%r9
mov    0x18(%rbp),%rax
mov    %rax,(%rsp)
call   1080 <e_p_konv_mess@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%edi
add    $0x1,%edi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    18a1 <e_p_comp_mess+0x731>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    186c <e_p_comp_mess+0x6fc>
mov    -0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x58(%rbp)
jne    18de <e_p_comp_mess+0x76e>
movl   $0x0,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x24,%eax
jne    19d5 <e_p_comp_mess+0x865>
movl   $0x0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    %rcx,%rax
cmp    -0x58(%rbp),%rax
jae    191d <e_p_comp_mess+0x7ad>
jmp    190f <e_p_comp_mess+0x79f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18f5 <e_p_comp_mess+0x785>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    %rcx,%rax
cmp    -0x58(%rbp),%rax
jae    1974 <e_p_comp_mess+0x804>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    193b <e_p_comp_mess+0x7cb>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
mov    0x10(%rbp),%r9
mov    0x18(%rbp),%rax
mov    %rax,(%rsp)
call   1080 <e_p_konv_mess@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x3c(%rbp)
je     19d0 <e_p_comp_mess+0x860>
movl   $0x0,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
jmp    19d5 <e_p_comp_mess+0x865>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    1a0a <e_p_comp_mess+0x89a>
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    1a0a <e_p_comp_mess+0x89a>
movl   $0x2,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    1a5f <e_p_comp_mess+0x8ef>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
add    $0x1,%rsi
mov    -0x58(%rbp),%rdx
add    $0x1,%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%r10
mov    0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <e_p_comp_mess@plt>
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rdi
movslq -0x44(%rbp),%rax
add    %rax,%rdi
movslq -0x40(%rbp),%rax
add    %rax,%rdi
mov    -0x58(%rbp),%rsi
movslq -0x40(%rbp),%rax
add    %rax,%rsi
mov    -0x58(%rbp),%rdx
movslq -0x40(%rbp),%rax
add    %rax,%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%r10
mov    0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <e_p_comp_mess@plt>
mov    %eax,-0x3c(%rbp)
cmp    $0x0,%eax
je     1ac0 <e_p_comp_mess+0x950>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1ae9 <e_p_comp_mess+0x979>
mov    0x10(%rbp),%rax
cmpl   $0xffffffff,(%rax)
jle    1ae9 <e_p_comp_mess+0x979>
movl   $0x0,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x24,%eax
jne    1b23 <e_p_comp_mess+0x9b3>
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
jmp    1b32 <e_p_comp_mess+0x9c2>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0x88(%rbp),%rsi
mov    -0x90(%rbp),%rdi
mov    -0x98(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%r10
mov    0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <e_p_comp_mess@plt>
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3f,%eax
jne    1ba7 <e_p_comp_mess+0xa37>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1ed1 <e_p_comp_mess+0xd61>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5b,%eax
jne    1ecc <e_p_comp_mess+0xd5c>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x21,%eax
jne    1d1a <e_p_comp_mess+0xbaa>
movl   $0x2,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x99(%rbp)
je     1c31 <e_p_comp_mess+0xac1>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
jne    1c13 <e_p_comp_mess+0xaa3>
xor    %eax,%eax
cmpl   $0x2,-0x44(%rbp)
mov    %al,-0x99(%rbp)
jne    1c31 <e_p_comp_mess+0xac1>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    1c44 <e_p_comp_mess+0xad4>
jmp    1cbf <e_p_comp_mess+0xb4f>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1cac <e_p_comp_mess+0xb3c>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jl     1cac <e_p_comp_mess+0xb3c>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
mov    -0x44(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     1cac <e_p_comp_mess+0xb3c>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
jmp    1cb1 <e_p_comp_mess+0xb41>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1bcf <e_p_comp_mess+0xa5f>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
je     1ce7 <e_p_comp_mess+0xb77>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%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    1ec7 <e_p_comp_mess+0xd57>
movl   $0x1,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x9a(%rbp)
je     1d83 <e_p_comp_mess+0xc13>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
jne    1d65 <e_p_comp_mess+0xbf5>
xor    %eax,%eax
cmpl   $0x1,-0x44(%rbp)
mov    %al,-0x9a(%rbp)
jne    1d83 <e_p_comp_mess+0xc13>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x9a(%rbp)
mov    -0x9a(%rbp),%al
test   $0x1,%al
jne    1d96 <e_p_comp_mess+0xc26>
jmp    1e03 <e_p_comp_mess+0xc93>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1df0 <e_p_comp_mess+0xc80>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jl     1df0 <e_p_comp_mess+0xc80>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
mov    -0x44(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     1df0 <e_p_comp_mess+0xc80>
jmp    1e03 <e_p_comp_mess+0xc93>
jmp    1df5 <e_p_comp_mess+0xc85>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1d21 <e_p_comp_mess+0xbb1>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
je     1e2d <e_p_comp_mess+0xcbd>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1e39 <e_p_comp_mess+0xcc9>
movl   $0x0,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
jmp    1e3e <e_p_comp_mess+0xcce>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x9b(%rbp)
je     1e73 <e_p_comp_mess+0xd03>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5d,%eax
setne  %al
mov    %al,-0x9b(%rbp)
mov    -0x9b(%rbp),%al
test   $0x1,%al
jne    1e86 <e_p_comp_mess+0xd16>
jmp    1e99 <e_p_comp_mess+0xd29>
jmp    1e8b <e_p_comp_mess+0xd1b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1e3e <e_p_comp_mess+0xcce>
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%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    1ecc <e_p_comp_mess+0xd5c>
jmp    1ed1 <e_p_comp_mess+0xd61>
jmp    1ed6 <e_p_comp_mess+0xd66>
cmpl   $0x0,-0x40(%rbp)
jg     1f16 <e_p_comp_mess+0xda6>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%r10
mov    0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <e_p_comp_mess@plt>
mov    %eax,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x40(%rbp),%edx
call   1040 <strncmp@plt>
mov    %eax,-0x44(%rbp)
cmp    $0x0,%eax
je     1f3e <e_p_comp_mess+0xdce>
movl   $0x0,-0x4(%rbp)
jmp    1f84 <e_p_comp_mess+0xe14>
mov    -0x10(%rbp),%rdi
movslq -0x40(%rbp),%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rsi
movslq -0x40(%rbp),%rax
add    %rax,%rsi
mov    -0x20(%rbp),%rdx
movslq -0x40(%rbp),%rax
add    %rax,%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x10(%rbp),%r10
mov    0x18(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <e_p_comp_mess@plt>
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<e_p_comp_mess>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,0x30(%rsp)
mov    %rcx,0x28(%rsp)
xor    %ecx,%ecx
cmp    %rsi,%rdx
ja     1ee1 <e_p_comp_mess+0xd71>
mov    %rsi,%r15
mov    %r8,0x10(%rsp)
lea    0x1(%rdi),%rbx
lea    0x2(%rdi),%rax
mov    %rax,0x58(%rsp)
lea    0x70(%rdi),%rax
mov    %rax,0x60(%rsp)
lea    0x10(%rdi),%rax
mov    %rax,0x68(%rsp)
lea    0x3(%rdi),%rax
mov    %rax,0x70(%rsp)
mov    %rdi,0x18(%rsp)
mov    %rbx,0x48(%rsp)
mov    (%rdi),%r8b
cmp    $0x2a,%r8b
mov    %rdx,(%rsp)
mov    %r15,0x8(%rsp)
je     1270 <e_p_comp_mess+0x100>
test   %r8b,%r8b
je     1d41 <e_p_comp_mess+0xbd1>
mov    (%r15),%r10b
test   %r10b,%r10b
je     1edf <e_p_comp_mess+0xd6f>
cmp    $0x24,%r8b
sete   %r12b
jne    12b0 <e_p_comp_mess+0x140>
cmpb   $0x7b,(%rbx)
jne    12b4 <e_p_comp_mess+0x144>
mov    %r8b,0x40(%rsp)
mov    %r10b,0x38(%rsp)
mov    $0x2,%ebp
mov    $0x2,%r15d
mov    $0x2,%r13b
xor    %r14d,%r14d
movabs $0x100000000,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rdi,%rbp,1),%ebx
test   %bl,%bl
je     1602 <e_p_comp_mess+0x492>
cmp    $0x7d,%bl
je     1602 <e_p_comp_mess+0x492>
add    $0x1,%rbp
add    %rax,%r14
add    $0x1,%r15d
add    $0x1,%r13b
jmp    1240 <e_p_comp_mess+0xd0>
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx),%al
test   %al,%al
je     1d37 <e_p_comp_mess+0xbc7>
mov    (%r15),%r10b
test   %r10b,%r10b
je     1edf <e_p_comp_mess+0xd6f>
cmp    $0x2a,%al
je     1b9e <e_p_comp_mess+0xa2e>
cmp    $0x24,%al
je     1b9e <e_p_comp_mess+0xa2e>
xor    %eax,%eax
cmpb   $0x5c,(%rbx)
je     12b6 <e_p_comp_mess+0x146>
xor    %eax,%eax
mov    %rax,0x50(%rsp)
mov    $0x1,%esi
mov    $0x2,%ebp
jmp    12c2 <e_p_comp_mess+0x152>
xor    %eax,%eax
jmp    12b6 <e_p_comp_mess+0x146>
mov    $0x1,%al
mov    %rax,0x50(%rsp)
xor    %esi,%esi
mov    $0x1,%ebp
xor    %eax,%eax
mov    %rax,0x20(%rsp)
movslq %ebp,%r12
mov    %r12d,%r14d
sub    %esi,%r14d
mov    %r12d,%r15d
sub    %sil,%r15b
lea    -0x3(%r12),%ebp
lea    -0x2(%r12),%eax
xor    %ecx,%ecx
jmp    1312 <e_p_comp_mess+0x1a2>
mov    $0x24,%bl
cmpb   $0x7b,0x1(%r12,%rdi,1)
je     133a <e_p_comp_mess+0x1ca>
test   %ecx,%ecx
sete   %cl
cmp    $0x5c,%bl
sete   %bl
and    %cl,%bl
movzbl %bl,%ecx
add    $0x1,%r12
add    $0x1,%r14d
add    $0x1,%r15b
add    $0x1,%ebp
add    $0x1,%eax
movzbl (%rdi,%r12,1),%ebx
test   %ecx,%ecx
jne    12f0 <e_p_comp_mess+0x180>
cmp    $0x29,%bl
jg     132b <e_p_comp_mess+0x1bb>
cmp    $0x24,%bl
je     12e6 <e_p_comp_mess+0x176>
test   %bl,%bl
jne    12f0 <e_p_comp_mess+0x180>
jmp    133a <e_p_comp_mess+0x1ca>
cmp    $0x2a,%bl
je     133a <e_p_comp_mess+0x1ca>
cmp    $0x3f,%bl
je     133a <e_p_comp_mess+0x1ca>
cmp    $0x5b,%bl
jne    12f0 <e_p_comp_mess+0x180>
cmp    $0x29,%r8b
jle    1350 <e_p_comp_mess+0x1e0>
cmp    $0x2a,%r8b
je     135a <e_p_comp_mess+0x1ea>
jmp    1ab8 <e_p_comp_mess+0x948>
nopl   0x0(%rax,%rax,1)
cmp    $0x24,%r8b
jne    1b6e <e_p_comp_mess+0x9fe>
movslq %esi,%r13
mov    (%rdi,%r13,1),%al
cmp    $0x3f,%al
je     1c58 <e_p_comp_mess+0xae8>
lea    (%rdi,%r13,1),%rbp
cmp    $0x5b,%al
je     1caf <e_p_comp_mess+0xb3f>
mov    %r12d,%ebx
mov    %rsi,0x40(%rsp)
sub    %esi,%ebx
lea    0x1(%rbx),%edi
call   1070 <malloc@plt>
mov    %rbx,%r10
mov    0x18(%rsp),%rcx
mov    %rax,%rbx
test   %r10d,%r10d
jle    1430 <e_p_comp_mess+0x2c0>
mov    %r10d,%r9d
cmp    $0x8,%r10d
jb     13c1 <e_p_comp_mess+0x251>
lea    (%r9,%r13,1),%rax
add    %rcx,%rax
cmp    %rax,%rbx
jae    15f5 <e_p_comp_mess+0x485>
lea    (%rbx,%r9,1),%rax
cmp    %rax,%rbp
jae    15f5 <e_p_comp_mess+0x485>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r9,%rsi
test   $0x3,%r9b
je     13f2 <e_p_comp_mess+0x282>
movzbl %r15b,%ecx
and    $0x3,%ecx
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rax,1),%edx
mov    %dl,(%rbx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    13e0 <e_p_comp_mess+0x270>
cmp    $0x3,%rsi
jb     1430 <e_p_comp_mess+0x2c0>
mov    %r14d,%ecx
add    0x70(%rsp),%r13
movzbl -0x3(%r13,%rax,1),%edx
mov    %dl,(%rbx,%rax,1)
movzbl -0x2(%r13,%rax,1),%edx
mov    %dl,0x1(%rbx,%rax,1)
movzbl -0x1(%r13,%rax,1),%edx
mov    %dl,0x2(%rbx,%rax,1)
movzbl 0x0(%r13,%rax,1),%edx
mov    %dl,0x3(%rbx,%rax,1)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1400 <e_p_comp_mess+0x290>
movslq %r10d,%r14
movb   $0x0,(%rbx,%r14,1)
mov    0x8(%rsp),%rdi
mov    %rbx,%rsi
call   1090 <strstr@plt>
mov    %rax,%r15
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %ecx,%ecx
test   %r15,%r15
je     1ee1 <e_p_comp_mess+0xd71>
cmpb   $0x0,0x50(%rsp)
je     154f <e_p_comp_mess+0x3df>
mov    (%rsp),%rax
add    $0xffffffffffffffff,%rax
xor    %edi,%edi
add    $0x1,%edi
add    $0x1,%rax
cmp    %r15,%rax
jb     1470 <e_p_comp_mess+0x300>
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    (%rsp),%r9
cmp    %r15,%r9
mov    %rbp,0x38(%rsp)
jae    14e5 <e_p_comp_mess+0x375>
mov    %r15,%rax
sub    %r9,%rax
cmp    $0x8,%rax
jb     14b8 <e_p_comp_mess+0x348>
lea    (%r9,%rax,1),%rcx
cmp    %rcx,%rbx
jae    167e <e_p_comp_mess+0x50e>
lea    (%rbx,%rax,1),%rcx
cmp    %rcx,%r9
jae    167e <e_p_comp_mess+0x50e>
xor    %ecx,%ecx
mov    %r9,%rdx
mov    %r15,%r13
lea    0x1(%r9),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rdx),%edx
mov    %dl,(%rbx,%rcx,1)
lea    (%rsi,%rcx,1),%rdx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    14d0 <e_p_comp_mess+0x360>
jmp    14ea <e_p_comp_mess+0x37a>
mov    %r15,%r13
xor    %eax,%eax
mov    %eax,%eax
movb   $0x0,(%rbx,%rax,1)
sub    $0x8,%rsp
mov    0x28(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x30(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    0x38(%rsp),%r8
mov    0xb8(%rsp),%r9
push   0xc0(%rsp)
call   1080 <e_p_konv_mess@plt>
add    $0x10,%rsp
mov    %eax,%r15d
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
test   %r15d,%r15d
mov    %r13,%r15
mov    $0x0,%ecx
mov    0x38(%rsp),%rbp
jne    1edf <e_p_comp_mess+0xd6f>
mov    0x18(%rsp),%rdi
cmpb   $0x0,(%rdi,%r12,1)
je     15d0 <e_p_comp_mess+0x460>
add    %r14,%rbp
add    %r15,%r14
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %r14,%rdx
mov    0x28(%rsp),%rcx
mov    0x10(%rsp),%rbx
mov    %rbx,%r8
mov    0x30(%rsp),%r9
push   0xb8(%rsp)
push   0xb8(%rsp)
call   1060 <e_p_comp_mess@plt>
add    $0x10,%rsp
test   %eax,%eax
jne    1d51 <e_p_comp_mess+0xbe1>
cmpb   $0x0,(%rbx)
je     15b1 <e_p_comp_mess+0x441>
mov    0xb0(%rsp),%rax
cmpl   $0x0,(%rax)
jns    1edf <e_p_comp_mess+0xd6f>
add    $0x1,%r15
mov    0x18(%rsp),%rdi
cmpb   $0x24,(%rdi)
mov    (%rsp),%rdx
cmovne %r15,%rdx
xor    %ecx,%ecx
jmp    15e2 <e_p_comp_mess+0x472>
nopl   0x0(%rax)
cmpb   $0x0,(%r15,%r14,1)
je     1d37 <e_p_comp_mess+0xbc7>
add    $0x1,%r15
mov    %r15,%rdx
cmp    %r15,%rdx
mov    0x48(%rsp),%rbx
jbe    11cd <e_p_comp_mess+0x5d>
jmp    1ee1 <e_p_comp_mess+0xd71>
cmp    $0x20,%r10d
jae    165c <e_p_comp_mess+0x4ec>
xor    %eax,%eax
jmp    176e <e_p_comp_mess+0x5fe>
lea    -0x1(%rbp),%edi
call   1070 <malloc@plt>
mov    0x18(%rsp),%rdi
cmp    $0x3,%ebp
jb     1a6b <e_p_comp_mess+0x8fb>
mov    %ebp,%r10d
lea    -0x2(%r10),%r9
mov    $0x2,%esi
cmp    $0x8,%r9
jb     1a00 <e_p_comp_mess+0x890>
lea    (%rdi,%r10,1),%rcx
cmp    %rcx,%rax
jae    164a <e_p_comp_mess+0x4da>
lea    (%rax,%r10,1),%rcx
add    $0xfffffffffffffffe,%rcx
cmp    %rcx,0x58(%rsp)
jb     1a00 <e_p_comp_mess+0x890>
cmp    $0x20,%r9
jae    18c2 <e_p_comp_mess+0x752>
xor    %r11d,%r11d
jmp    19c2 <e_p_comp_mess+0x852>
mov    %r9d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
cmp    $0x60,%rcx
jae    168f <e_p_comp_mess+0x51f>
xor    %edx,%edx
jmp    1708 <e_p_comp_mess+0x598>
cmp    $0x20,%rax
jae    17b0 <e_p_comp_mess+0x640>
xor    %ecx,%ecx
jmp    1884 <e_p_comp_mess+0x714>
mov    0x60(%rsp),%rcx
lea    (%rcx,%r13,1),%rdi
mov    %r14d,%esi
and    $0xffffffe0,%esi
add    $0xffffffffffffffe0,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
movups -0x70(%rdi,%rdx,1),%xmm0
movups -0x60(%rdi,%rdx,1),%xmm1
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,0x10(%rbx,%rdx,1)
movups -0x50(%rdi,%rdx,1),%xmm0
movups -0x40(%rdi,%rdx,1),%xmm1
movups %xmm0,0x20(%rbx,%rdx,1)
movups %xmm1,0x30(%rbx,%rdx,1)
movups -0x30(%rdi,%rdx,1),%xmm0
movups -0x20(%rdi,%rdx,1),%xmm1
movups %xmm0,0x40(%rbx,%rdx,1)
movups %xmm1,0x50(%rbx,%rdx,1)
movups -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movups %xmm0,0x60(%rbx,%rdx,1)
movups %xmm1,0x70(%rbx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rsi
jne    16b0 <e_p_comp_mess+0x540>
test   $0x3,%r8b
je     175b <e_p_comp_mess+0x5eb>
lea    (%rbx,%rdx,1),%rsi
add    $0x10,%rsi
add    %r13,%rdx
add    0x68(%rsp),%rdx
mov    %r14d,%ecx
and    $0x60,%cl
add    $0xe0,%cl
shr    $0x5,%cl
add    $0x1,%cl
movzbl %cl,%edi
and    $0x3,%edi
shl    $0x5,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups -0x10(%rdx,%rcx,1),%xmm0
movups (%rdx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rcx,1)
movups %xmm1,(%rsi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdi
jne    1740 <e_p_comp_mess+0x5d0>
cmp    %r9,%rax
je     1430 <e_p_comp_mess+0x2c0>
test   $0x18,%r9b
je     13c3 <e_p_comp_mess+0x253>
mov    %rax,%rdx
mov    %r12d,%esi
sub    0x40(%rsp),%esi
mov    %esi,%eax
and    $0xfffffff8,%eax
mov    %r14d,%edi
and    $0xfffffff8,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%rbp,%rdx,1),%rcx
mov    %rcx,(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rdi
jne    1790 <e_p_comp_mess+0x620>
cmp    %rsi,%rax
je     1430 <e_p_comp_mess+0x2c0>
jmp    13c3 <e_p_comp_mess+0x253>
mov    %rax,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rdx
jae    17d7 <e_p_comp_mess+0x667>
xor    %edi,%edi
jmp    1840 <e_p_comp_mess+0x6d0>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   (%rax)
movups (%r9,%rdi,1),%xmm0
movups 0x10(%r9,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
movups 0x20(%r9,%rdi,1),%xmm0
movups 0x30(%r9,%rdi,1),%xmm1
movups %xmm0,0x20(%rbx,%rdi,1)
movups %xmm1,0x30(%rbx,%rdi,1)
movups 0x40(%r9,%rdi,1),%xmm0
movups 0x50(%r9,%rdi,1),%xmm1
movups %xmm0,0x40(%rbx,%rdi,1)
movups %xmm1,0x50(%rbx,%rdi,1)
movups 0x60(%r9,%rdi,1),%xmm0
movups 0x70(%r9,%rdi,1),%xmm1
movups %xmm0,0x60(%rbx,%rdi,1)
movups %xmm1,0x70(%rbx,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    17e0 <e_p_comp_mess+0x670>
test   %r8,%r8
je     187b <e_p_comp_mess+0x70b>
lea    (%rbx,%rdi,1),%rsi
add    $0x10,%rsi
add    %r9,%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1860 <e_p_comp_mess+0x6f0>
cmp    %rcx,%rax
je     18ba <e_p_comp_mess+0x74a>
test   $0x18,%al
je     18e5 <e_p_comp_mess+0x775>
mov    %rcx,%rdi
mov    %r15,%r8
sub    %r9,%r8
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%r9,%rcx,1),%rdx
nopl   0x0(%rax,%rax,1)
mov    (%r9,%rdi,1),%rsi
mov    %rsi,(%rbx,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rcx
jne    18a0 <e_p_comp_mess+0x730>
cmp    %rcx,%r8
jne    14bd <e_p_comp_mess+0x34d>
mov    %r15,%r13
jmp    14ea <e_p_comp_mess+0x37a>
mov    %r9,%r11
and    $0xffffffffffffffe0,%r11
lea    -0x20(%r11),%rsi
mov    %rsi,%r8
shr    $0x5,%r8
add    $0x1,%r8
cmp    $0x60,%rsi
jae    18ee <e_p_comp_mess+0x77e>
xor    %esi,%esi
jmp    1969 <e_p_comp_mess+0x7f9>
lea    (%r9,%rcx,1),%rdx
jmp    14bd <e_p_comp_mess+0x34d>
mov    %r15d,%edx
add    $0xfffffffffffffffe,%rdx
and    $0xffffffffffffffe0,%rdx
add    $0xffffffffffffffe0,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups 0x2(%rdi,%rsi,1),%xmm0
movups 0x12(%rdi,%rsi,1),%xmm1
movups %xmm0,(%rax,%rsi,1)
movups %xmm1,0x10(%rax,%rsi,1)
movups 0x22(%rdi,%rsi,1),%xmm0
movups 0x32(%rdi,%rsi,1),%xmm1
movups %xmm0,0x20(%rax,%rsi,1)
movups %xmm1,0x30(%rax,%rsi,1)
movups 0x42(%rdi,%rsi,1),%xmm0
movups 0x52(%rdi,%rsi,1),%xmm1
movups %xmm0,0x40(%rax,%rsi,1)
movups %xmm1,0x50(%rax,%rsi,1)
movups 0x62(%rdi,%rsi,1),%xmm0
movups 0x72(%rdi,%rsi,1),%xmm1
movups %xmm0,0x60(%rax,%rsi,1)
movups %xmm1,0x70(%rax,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1910 <e_p_comp_mess+0x7a0>
test   $0x3,%r8b
je     19b3 <e_p_comp_mess+0x843>
lea    -0x2(%r15),%ecx
and    $0x60,%cl
add    $0xe0,%cl
shr    $0x5,%cl
add    $0x1,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rsi,%rdx
or     $0x2,%rdx
movups (%rdi,%rdx,1),%xmm0
movups 0x10(%rdi,%rdx,1),%xmm1
movups %xmm0,(%rax,%rsi,1)
movups %xmm1,0x10(%rax,%rsi,1)
add    $0x20,%rsi
add    $0xffffffffffffffff,%rcx
jne    1990 <e_p_comp_mess+0x820>
cmp    %r11,%r9
je     1a6b <e_p_comp_mess+0x8fb>
test   $0x18,%r9b
je     19f9 <e_p_comp_mess+0x889>
mov    %ebp,%r8d
add    $0xfffffffffffffffe,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    0x2(%r9),%rsi
mov    %r15d,%edx
add    $0xfffffffffffffffe,%rdx
and    $0xfffffffffffffff8,%rdx
nop
mov    0x2(%rdi,%r11,1),%rcx
mov    %rcx,(%rax,%r11,1)
add    $0x8,%r11
cmp    %r11,%rdx
jne    19e0 <e_p_comp_mess+0x870>
cmp    %r9,%r8
jne    1a00 <e_p_comp_mess+0x890>
jmp    1a6b <e_p_comp_mess+0x8fb>
or     $0x2,%r11
mov    %r11,%rsi
mov    %ebp,%ecx
sub    %esi,%ecx
mov    %rsi,%rdx
not    %rdx
add    %rdx,%r10
test   $0x3,%cl
je     1a32 <e_p_comp_mess+0x8c2>
sub    %sil,%r13b
movzbl %r13b,%ecx
and    $0x3,%ecx
nopl   0x0(%rax)
movzbl (%rdi,%rsi,1),%edx
mov    %dl,-0x2(%rax,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1a20 <e_p_comp_mess+0x8b0>
cmp    $0x3,%r10
jb     1a6b <e_p_comp_mess+0x8fb>
mov    %r15d,%edx
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%ecx
mov    %cl,-0x2(%rax,%rsi,1)
movzbl 0x1(%rdi,%rsi,1),%ecx
mov    %cl,-0x1(%rax,%rsi,1)
movzbl 0x2(%rdi,%rsi,1),%ecx
mov    %cl,(%rax,%rsi,1)
movzbl 0x3(%rdi,%rsi,1),%ecx
mov    %cl,0x1(%rax,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1a40 <e_p_comp_mess+0x8d0>
sar    $0x20,%r14
cmp    $0x1,%bl
mov    %rbp,%rsi
sbb    $0xffffffffffffffff,%rsi
movb   $0x0,(%rax,%r14,1)
mov    %esi,%ecx
mov    (%rdi,%rcx,1),%dl
test   %dl,%dl
je     1ef2 <e_p_comp_mess+0xd82>
mov    %r12,0x50(%rsp)
mov    %rax,0x20(%rsp)
xor    %ecx,%ecx
cmp    $0x5c,%dl
setne  %cl
cmp    $0x1,%bl
sbb    $0xffffffff,%ecx
add    %ecx,%ebp
mov    (%rsp),%rdx
mov    0x38(%rsp),%r10b
mov    0x40(%rsp),%r8b
jmp    12c9 <e_p_comp_mess+0x159>
cmp    $0x3f,%r8b
je     1b50 <e_p_comp_mess+0x9e0>
cmp    $0x5b,%r8b
jne    1b6e <e_p_comp_mess+0x9fe>
mov    0x48(%rsp),%rcx
mov    (%rcx),%r8b
cmp    $0x21,%r8b
je     1bb1 <e_p_comp_mess+0xa41>
xor    %ecx,%ecx
test   %r8b,%r8b
mov    0x8(%rsp),%r15
je     1ee1 <e_p_comp_mess+0xd71>
mov    $0x1,%esi
mov    $0x2,%r9d
mov    $0x1,%ebp
jmp    1b17 <e_p_comp_mess+0x9a7>
add    $0x1,%rsi
add    $0x1,%r9d
add    $0xffffffff,%eax
add    $0x1,%ebp
test   %r8b,%r8b
je     1ee1 <e_p_comp_mess+0xd71>
mov    %r8d,%ebx
cmp    $0x5d,%r8b
jne    1b2a <e_p_comp_mess+0x9ba>
cmp    $0x1,%rsi
jne    1ee1 <e_p_comp_mess+0xd71>
cmp    %r10b,%bl
je     1c08 <e_p_comp_mess+0xa98>
movzbl 0x1(%rdi,%rsi,1),%r8d
cmp    $0x2d,%r8b
jne    1b00 <e_p_comp_mess+0x990>
cmp    %bl,%r10b
jl     1b00 <e_p_comp_mess+0x990>
cmp    0x2(%rdi,%rsi,1),%r10b
jg     1b00 <e_p_comp_mess+0x990>
jmp    1c0b <e_p_comp_mess+0xa9b>
add    $0xffffffff,%r12d
mov    0x8(%rsp),%r15
add    $0x1,%r15
mov    0x48(%rsp),%rdi
mov    %r12d,%ebp
test   %ebp,%ebp
jg     1b7a <e_p_comp_mess+0xa0a>
mov    %rdi,%rbx
jmp    1b9e <e_p_comp_mess+0xa2e>
mov    %r12d,%ebp
mov    0x8(%rsp),%r15
test   %ebp,%ebp
jle    1b69 <e_p_comp_mess+0x9f9>
mov    %r15,%rsi
mov    %ebp,%edx
mov    %rdi,%rbx
call   1040 <strncmp@plt>
test   %eax,%eax
jne    1edf <e_p_comp_mess+0xd6f>
mov    %ebp,%eax
add    %rax,%rbx
add    %rax,%r15
mov    (%rsp),%rdx
add    %rax,%rdx
xor    %ecx,%ecx
mov    %rbx,%rdi
cmp    %r15,%rdx
jbe    119b <e_p_comp_mess+0x2b>
jmp    1ee1 <e_p_comp_mess+0xd71>
mov    0x2(%rdi),%sil
test   %sil,%sil
mov    0x8(%rsp),%r15
je     1f2e <e_p_comp_mess+0xdbe>
mov    $0x3,%eax
jmp    1bda <e_p_comp_mess+0xa6a>
add    $0x1,%rax
add    $0xffffffff,%ebp
test   %sil,%sil
je     1f2e <e_p_comp_mess+0xdbe>
mov    %esi,%ecx
cmp    $0x5d,%sil
jne    1be8 <e_p_comp_mess+0xa78>
cmp    $0x3,%rax
jne    1c42 <e_p_comp_mess+0xad2>
cmp    %r10b,%cl
je     1c38 <e_p_comp_mess+0xac8>
movzbl (%rdi,%rax,1),%esi
cmp    $0x2d,%sil
jne    1bca <e_p_comp_mess+0xa5a>
cmp    %cl,%r10b
jl     1bca <e_p_comp_mess+0xa5a>
cmp    0x1(%rdi,%rax,1),%r10b
jg     1bca <e_p_comp_mess+0xa5a>
jmp    1f2e <e_p_comp_mess+0xdbe>
mov    %r10d,%ebx
cmp    $0x5d,%bl
je     1ee1 <e_p_comp_mess+0xd71>
mov    %ebp,%ecx
add    %rdi,%rcx
mov    %eax,%ebp
movzbl (%rcx),%eax
test   %al,%al
je     1c33 <e_p_comp_mess+0xac3>
cmp    $0x5d,%al
je     1c33 <e_p_comp_mess+0xac3>
add    $0x1,%r9d
add    $0xffffffff,%ebp
add    $0x1,%rcx
jmp    1c1b <e_p_comp_mess+0xaab>
mov    %r9d,%eax
jmp    1c44 <e_p_comp_mess+0xad4>
cmp    $0x5d,%r10b
jne    1f2e <e_p_comp_mess+0xdbe>
mov    %eax,%eax
add    %rax,%rdi
add    $0x1,%r15
test   %ebp,%ebp
jg     1b7a <e_p_comp_mess+0xa0a>
jmp    1b69 <e_p_comp_mess+0x9f9>
mov    %rsi,%rbx
call   1050 <strlen@plt>
lea    0x1(%rax),%edi
call   1070 <malloc@plt>
mov    %rbx,%rcx
mov    %rax,%rbx
test   %ecx,%ecx
jle    1d58 <e_p_comp_mess+0xbe8>
mov    %ecx,%ecx
xor    %eax,%eax
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rdi
xchg   %ax,%ax
movzbl (%rsi,%rax,1),%edx
mov    %dl,(%rbx,%rax,1)
test   %dl,%dl
je     1d6e <e_p_comp_mess+0xbfe>
add    $0x1,%rax
cmp    %rax,%rcx
jne    1c90 <e_p_comp_mess+0xb20>
mov    %ecx,%eax
jmp    1d6e <e_p_comp_mess+0xbfe>
mov    0x8(%rsp),%r15
cmpb   $0x0,(%r15)
je     1edf <e_p_comp_mess+0xd6f>
mov    %rbp,0x38(%rsp)
xor    %ebx,%ebx
xor    %r13d,%r13d
xor    %ebp,%ebp
mov    0x10(%rsp),%r14
mov    (%rsp),%rax
mov    0x20(%rsp),%r12
nopl   0x0(%rax,%rax,1)
lea    (%r15,%rbp,1),%rsi
lea    (%rax,%rbp,1),%rdx
mov    0x38(%rsp),%rdi
mov    0x28(%rsp),%rcx
mov    %r14,%r8
mov    0x30(%rsp),%r9
push   0xb8(%rsp)
push   0xb8(%rsp)
call   1060 <e_p_comp_mess@plt>
add    $0x10,%rsp
test   %eax,%eax
jne    1dcc <e_p_comp_mess+0xc5c>
add    $0x1,%r13b
add    $0x1,%bl
xor    %ecx,%ecx
cmpb   $0x0,0x1(%r15,%rbp,1)
lea    0x1(%rbp),%rbp
mov    (%rsp),%rax
jne    1ce0 <e_p_comp_mess+0xb70>
jmp    1ee1 <e_p_comp_mess+0xd71>
mov    $0x2,%ecx
jmp    1ee1 <e_p_comp_mess+0xd71>
xor    %ecx,%ecx
cmpb   $0x0,(%r15)
sete   %cl
add    %ecx,%ecx
jmp    1ee1 <e_p_comp_mess+0xd71>
mov    %eax,%ecx
jmp    1ee1 <e_p_comp_mess+0xd71>
xor    %eax,%eax
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    %eax,%eax
movzbl 0x1(%rsi,%rax,1),%ecx
mov    %cl,(%rbx,%rax,1)
add    $0x1,%rax
test   %cl,%cl
jne    1d70 <e_p_comp_mess+0xc00>
call   1030 <free@plt>
add    $0x1,%rbp
mov    (%rsp),%rdx
add    $0x1,%rdx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    0x28(%rsp),%rcx
mov    %r14,%r8
mov    0x30(%rsp),%r9
push   0xb8(%rsp)
push   0xb8(%rsp)
call   1060 <e_p_comp_mess@plt>
add    $0x10,%rsp
mov    %eax,%ebp
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
jmp    1ee3 <e_p_comp_mess+0xd73>
mov    %eax,%ecx
cmpb   $0x0,(%r15,%rbp,1)
mov    0x18(%rsp),%rax
je     1edf <e_p_comp_mess+0xd6f>
cmpb   $0x24,(%rax)
jne    1ee1 <e_p_comp_mess+0xd71>
mov    %ecx,(%rsp)
mov    %ebp,%r14d
lea    0x1(%rbp),%edi
call   1070 <malloc@plt>
mov    %r15,%r8
mov    %rax,%r15
test   %ebp,%ebp
je     1e94 <e_p_comp_mess+0xd24>
cmp    $0x8,%r14d
jb     1e28 <e_p_comp_mess+0xcb8>
lea    (%r8,%r14,1),%rax
cmp    %rax,%r15
jae    1f36 <e_p_comp_mess+0xdc6>
mov    %r8,%rcx
mov    %r15,%rax
add    %r14,%rax
cmp    %rax,%r8
jae    1f36 <e_p_comp_mess+0xdc6>
xor    %eax,%eax
mov    %ebp,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
test   $0x3,%dl
je     1e59 <e_p_comp_mess+0xce9>
sub    %al,%r13b
movzbl %r13b,%edx
and    $0x3,%edx
movzbl (%r8,%rax,1),%ebx
mov    %bl,(%r15,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1e46 <e_p_comp_mess+0xcd6>
cmp    $0x3,%rcx
jb     1e94 <e_p_comp_mess+0xd24>
mov    %ebp,%ecx
movzbl (%r8,%rax,1),%edx
mov    %dl,(%r15,%rax,1)
movzbl 0x1(%r8,%rax,1),%edx
mov    %dl,0x1(%r15,%rax,1)
movzbl 0x2(%r8,%rax,1),%edx
mov    %dl,0x2(%r15,%rax,1)
movzbl 0x3(%r8,%rax,1),%edx
mov    %dl,0x3(%r15,%rax,1)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1e61 <e_p_comp_mess+0xcf1>
movb   $0x0,(%r15,%r14,1)
sub    $0x8,%rsp
mov    %r12,%rdi
mov    %r15,%rsi
mov    0x30(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    0x38(%rsp),%r8
mov    0xb8(%rsp),%r9
push   0xc0(%rsp)
call   1080 <e_p_konv_mess@plt>
add    $0x10,%rsp
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    (%rsp),%ecx
jmp    1ee1 <e_p_comp_mess+0xd71>
xor    %ecx,%ecx
mov    %ecx,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
sub    $0x8,%rsp
mov    %rax,%rdi
mov    0x10(%rsp),%rsi
mov    0x30(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    0x38(%rsp),%r8
mov    0xb8(%rsp),%r9
push   0xc0(%rsp)
call   1080 <e_p_konv_mess@plt>
add    $0x10,%rsp
xor    %ecx,%ecx
test   %eax,%eax
sete   %cl
jmp    1ee1 <e_p_comp_mess+0xd71>
movsbl %r10b,%ecx
neg    %ecx
jmp    1ee1 <e_p_comp_mess+0xd71>
cmp    $0x20,%r14d
jae    1f43 <e_p_comp_mess+0xdd3>
xor    %eax,%eax
mov    %r8,%rbx
jmp    1f8d <e_p_comp_mess+0xe1d>
mov    %ebp,%edx
mov    %ebp,%ecx
and    $0x1f,%ecx
mov    %r14,%rax
sub    %rcx,%rax
movzbl %bl,%esi
and    $0x1f,%esi
sub    %rsi,%rdx
xor    %esi,%esi
mov    %r8,%rbx
movups (%rbx,%rsi,1),%xmm0
movups 0x10(%rbx,%rsi,1),%xmm1
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1f5e <e_p_comp_mess+0xdee>
test   %rcx,%rcx
je     1e94 <e_p_comp_mess+0xd24>
cmp    $0x8,%ecx
jb     1e2a <e_p_comp_mess+0xcba>
mov    %rax,%rcx
mov    %ebp,%esi
mov    %ebp,%edx
and    $0x7,%edx
mov    %r14,%rax
sub    %rdx,%rax
movzbl %r13b,%edi
and    $0x7,%edi
sub    %rdi,%rsi
mov    (%rbx,%rcx,1),%rdi
mov    %rdi,(%r15,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    1fa7 <e_p_comp_mess+0xe37>
test   %rdx,%rdx
jne    1e2a <e_p_comp_mess+0xcba>
jmp    1e94 <e_p_comp_mess+0xd24>

LLVM IR (-O0):
define i32 @e_p_comp_mess(i8* %0, i8* %1, i8* %2, i8* %3, i8* %4, i8* %5, i32* %6, i32* %7) {
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i8*
%23 = alloca i8*
%24 = alloca i8*
%25 = alloca i8*
store i8* %0, i8** %10
store i8* %1, i8** %11
store i8* %2, i8** %12
store i8* %3, i8** %13
store i8* %4, i8** %14
store i8* %5, i8** %15
store i32* %6, i32** %16
store i32* %7, i32** %17
store i32 0, i32* %20
store i32 0, i32* %21
store i8* null, i8** %24
store i8* null, i8** %25
%26 = load i8*, i8** %12
%27 = load i8*, i8** %11
%28 = icmp ugt i8* %26, %27
br i1 %28, label %29, label %30
29: ; preds = %8
store i32 0, i32* %9
br label %980
30: ; preds = %8
%31 = load i8*, i8** %10
%32 = getelementptr inbounds i8, i8* %31, i64 0
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp eq i32 %34, 42
br i1 %35, label %36, label %42
36: ; preds = %30
%37 = load i8*, i8** %10
%38 = getelementptr inbounds i8, i8* %37, i64 1
%39 = load i8, i8* %38
%40 = icmp ne i8 %39, 0
br i1 %40, label %42, label %41
41: ; preds = %36
store i32 2, i32* %9
br label %980
42: ; preds = %36, %30
%43 = load i8*, i8** %10
%44 = getelementptr inbounds i8, i8* %43, i64 0
%45 = load i8, i8* %44
%46 = icmp ne i8 %45, 0
br i1 %46, label %53, label %47
47: ; preds = %42
%48 = load i8*, i8** %11
%49 = getelementptr inbounds i8, i8* %48, i64 0
%50 = load i8, i8* %49
%51 = icmp ne i8 %50, 0
br i1 %51, label %53, label %52
52: ; preds = %47
store i32 2, i32* %9
br label %980
53: ; preds = %47, %42
%54 = load i8*, i8** %10
%55 = getelementptr inbounds i8, i8* %54, i64 0
%56 = load i8, i8* %55
%57 = icmp ne i8 %56, 0
br i1 %57, label %58, label %63
58: ; preds = %53
%59 = load i8*, i8** %11
%60 = getelementptr inbounds i8, i8* %59, i64 0
%61 = load i8, i8* %60
%62 = icmp ne i8 %61, 0
br i1 %62, label %64, label %63
63: ; preds = %58, %53
store i32 0, i32* %9
br label %980
64: ; preds = %58
%65 = load i8*, i8** %10
%66 = getelementptr inbounds i8, i8* %65, i64 0
%67 = load i8, i8* %66
%68 = sext i8 %67 to i32
%69 = icmp eq i32 %68, 42
br i1 %69, label %70, label %93
70: ; preds = %64
%71 = load i8*, i8** %10
%72 = getelementptr inbounds i8, i8* %71, i64 1
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = icmp eq i32 %74, 42
br i1 %75, label %82, label %76
76: ; preds = %70
%77 = load i8*, i8** %10
%78 = getelementptr inbounds i8, i8* %77, i64 1
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = icmp eq i32 %80, 36
br i1 %81, label %82, label %93
82: ; preds = %76, %70
%83 = load i8*, i8** %10
%84 = getelementptr inbounds i8, i8* %83, i32 1
store i8* %84, i8** %10
%85 = load i8*, i8** %11
%86 = load i8*, i8** %12
%87 = load i8*, i8** %13
%88 = load i8*, i8** %14
%89 = load i8*, i8** %15
%90 = load i32*, i32** %16
%91 = load i32*, i32** %17
%92 = call i32 @e_p_comp_mess(i8* %84, i8* %85, i8* %86, i8* %87, i8* %88, i8* %89, i32* %90, i32* %91)
store i32 %92, i32* %9
br label %980
93: ; preds = %76, %64
%94 = load i8*, i8** %10
%95 = getelementptr inbounds i8, i8* %94, i64 0
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = icmp eq i32 %97, 36
br i1 %98, label %99, label %202
99: ; preds = %93
%100 = load i8*, i8** %10
%101 = getelementptr inbounds i8, i8* %100, i64 1
%102 = load i8, i8* %101
%103 = sext i8 %102 to i32
%104 = icmp eq i32 %103, 123
br i1 %104, label %105, label %202
105: ; preds = %99
store i32 2, i32* %20
br label %106
106: ; preds = %125, %105
%107 = load i8*, i8** %10
%108 = load i32, i32* %20
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %107, i64 %109
%111 = load i8, i8* %110
%112 = sext i8 %111 to i32
%113 = icmp ne i32 %112, 0
br i1 %113, label %114, label %122
114: ; preds = %106
%115 = load i8*, i8** %10
%116 = load i32, i32* %20
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %115, i64 %117
%119 = load i8, i8* %118
%120 = sext i8 %119 to i32
%121 = icmp ne i32 %120, 125
br label %122
122: ; preds = %114, %106
%123 = phi i1 [ false, %106 ], [ %121, %114 ]
br i1 %123, label %124, label %128
124: ; preds = %122
br label %125
125: ; preds = %124
%126 = load i32, i32* %20
%127 = add nsw i32 %126, 1
store i32 %127, i32* %20
br label %106
128: ; preds = %122
%129 = load i32, i32* %20
%130 = sub nsw i32 %129, 1
%131 = sext i32 %130 to i64
%132 = mul i64 %131, 1
%133 = trunc i64 %132 to i32
%134 = call i8* @malloc(i32 %133)
store i8* %134, i8** %24
store i32 2, i32* %18
br label %135
135: ; preds = %150, %128
%136 = load i32, i32* %18
%137 = load i32, i32* %20
%138 = icmp slt i32 %136, %137
br i1 %138, label %139, label %153
139: ; preds = %135
%140 = load i8*, i8** %10
%141 = load i32, i32* %18
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i8, i8* %143
%145 = load i8*, i8** %24
%146 = load i32, i32* %18
%147 = sub nsw i32 %146, 2
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i8, i8* %145, i64 %148
store i8 %144, i8* %149
br label %150
150: ; preds = %139
%151 = load i32, i32* %18
%152 = add nsw i32 %151, 1
store i32 %152, i32* %18
br label %135
153: ; preds = %135
%154 = load i8*, i8** %24
%155 = load i32, i32* %20
%156 = sub nsw i32 %155, 2
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %154, i64 %157
store i8 0, i8* %158
%159 = load i8*, i8** %10
%160 = load i32, i32* %20
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i8, i8* %159, i64 %161
%163 = load i8, i8* %162
%164 = icmp ne i8 %163, 0
br i1 %164, label %165, label %168
165: ; preds = %153
%166 = load i32, i32* %20
%167 = add nsw i32 %166, 1
store i32 %167, i32* %20
br label %168
168: ; preds = %165, %153
%169 = load i8*, i8** %10
%170 = load i32, i32* %20
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i8, i8* %169, i64 %171
%173 = load i8, i8* %172
%174 = icmp ne i8 %173, 0
br i1 %174, label %187, label %175
175: ; preds = %168
%176 = load i8*, i8** %24
%177 = load i8*, i8** %11
%178 = load i8*, i8** %13
%179 = load i8*, i8** %14
%180 = load i8*, i8** %15
%181 = load i32*, i32** %16
%182 = load i32*, i32** %17
%183 = call i32 @e_p_konv_mess(i8* %176, i8* %177, i8* %178, i8* %179, i8* %180, i32* %181, i32* %182)
%184 = icmp ne i32 %183, 0
%185 = xor i1 %184, true
%186 = zext i1 %185 to i32
store i32 %186, i32* %9
br label %980
187: ; preds = %168
%188 = load i8*, i8** %10
%189 = load i32, i32* %20
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i8, i8* %188, i64 %190
%192 = load i8, i8* %191
%193 = sext i8 %192 to i32
%194 = icmp eq i32 %193, 92
br i1 %194, label %195, label %197
195: ; preds = %187
%196 = load i32, i32* %20
br label %200
197: ; preds = %187
%198 = load i32, i32* %20
%199 = add nsw i32 %198, 1
br label %200
200: ; preds = %197, %195
%201 = phi i32 [ %196, %195 ], [ %199, %197 ]
store i32 %201, i32* %19
br label %217
202: ; preds = %99, %93
%203 = load i8*, i8** %10
%204 = getelementptr inbounds i8, i8* %203, i64 0
%205 = load i8, i8* %204
%206 = sext i8 %205 to i32
%207 = icmp eq i32 %206, 42
br i1 %207, label %208, label %215
208: ; preds = %202
%209 = load i8*, i8** %10
%210 = getelementptr inbounds i8, i8* %209, i64 1
%211 = load i8, i8* %210
%212 = sext i8 %211 to i32
%213 = icmp ne i32 %212, 92
br i1 %213, label %214, label %215
214: ; preds = %208
store i32 1, i32* %20
store i32 2, i32* %19
br label %216
215: ; preds = %208, %202
store i32 1, i32* %19
br label %216
216: ; preds = %215, %214
br label %217
217: ; preds = %216, %200
br label %218
218: ; preds = %292, %217
%219 = load i32, i32* %21
%220 = icmp ne i32 %219, 0
br i1 %220, label %274, label %221
221: ; preds = %218
%222 = load i8*, i8** %10
%223 = load i32, i32* %19
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i8, i8* %222, i64 %224
%226 = load i8, i8* %225
%227 = sext i8 %226 to i32
%228 = icmp ne i32 %227, 0
br i1 %228, label %229, label %272
229: ; preds = %221
%230 = load i8*, i8** %10
%231 = load i32, i32* %19
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %230, i64 %232
%234 = load i8, i8* %233
%235 = sext i8 %234 to i32
%236 = icmp ne i32 %235, 42
br i1 %236, label %237, label %272
237: ; preds = %229
%238 = load i8*, i8** %10
%239 = load i32, i32* %19
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i8, i8* %238, i64 %240
%242 = load i8, i8* %241
%243 = sext i8 %242 to i32
%244 = icmp ne i32 %243, 63
br i1 %244, label %245, label %272
245: ; preds = %237
%246 = load i8*, i8** %10
%247 = load i32, i32* %19
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i8, i8* %246, i64 %248
%250 = load i8, i8* %249
%251 = sext i8 %250 to i32
%252 = icmp ne i32 %251, 91
br i1 %252, label %253, label %272
253: ; preds = %245
%254 = load i8*, i8** %10
%255 = load i32, i32* %19
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i8, i8* %254, i64 %256
%258 = load i8, i8* %257
%259 = sext i8 %258 to i32
%260 = icmp ne i32 %259, 36
br i1 %260, label %270, label %261
261: ; preds = %253
%262 = load i8*, i8** %10
%263 = load i32, i32* %19
%264 = add nsw i32 %263, 1
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i8, i8* %262, i64 %265
%267 = load i8, i8* %266
%268 = sext i8 %267 to i32
%269 = icmp ne i32 %268, 123
br label %270
270: ; preds = %261, %253
%271 = phi i1 [ true, %253 ], [ %269, %261 ]
br label %272
272: ; preds = %270, %245, %237, %229, %221
%273 = phi i1 [ false, %245 ], [ false, %237 ], [ false, %229 ], [ false, %221 ], [ %271, %270 ]
br label %274
274: ; preds = %272, %218
%275 = phi i1 [ true, %218 ], [ %273, %272 ]
br i1 %275, label %276, label %295
276: ; preds = %274
%277 = load i8*, i8** %10
%278 = load i32, i32* %19
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds i8, i8* %277, i64 %279
%281 = load i8, i8* %280
%282 = sext i8 %281 to i32
%283 = icmp eq i32 %282, 92
br i1 %283, label %284, label %289
284: ; preds = %276
%285 = load i32, i32* %21
%286 = icmp ne i32 %285, 0
%287 = xor i1 %286, true
%288 = zext i1 %287 to i32
br label %290
289: ; preds = %276
br label %290
290: ; preds = %289, %284
%291 = phi i32 [ %288, %284 ], [ 0, %289 ]
store i32 %291, i32* %21
br label %292
292: ; preds = %290
%293 = load i32, i32* %19
%294 = add nsw i32 %293, 1
store i32 %294, i32* %19
br label %218
295: ; preds = %274
%296 = load i8*, i8** %10
%297 = getelementptr inbounds i8, i8* %296, i64 0
%298 = load i8, i8* %297
%299 = sext i8 %298 to i32
%300 = icmp eq i32 %299, 42
br i1 %300, label %307, label %301
301: ; preds = %295
%302 = load i8*, i8** %10
%303 = getelementptr inbounds i8, i8* %302, i64 0
%304 = load i8, i8* %303
%305 = sext i8 %304 to i32
%306 = icmp eq i32 %305, 36
br i1 %306, label %307, label %684
307: ; preds = %301, %295
%308 = load i8*, i8** %10
%309 = load i32, i32* %20
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i8, i8* %308, i64 %310
%312 = load i8, i8* %311
%313 = sext i8 %312 to i32
%314 = icmp eq i32 %313, 63
br i1 %314, label %315, label %382
315: ; preds = %307
%316 = load i8*, i8** %10
%317 = call i32 @strlen(i8* %316)
%318 = add nsw i32 %317, 1
%319 = sext i32 %318 to i64
%320 = mul i64 %319, 1
%321 = trunc i64 %320 to i32
%322 = call i8* @malloc(i32 %321)
store i8* %322, i8** %23
store i32 0, i32* %18
br label %323
323: ; preds = %342, %315
%324 = load i32, i32* %18
%325 = load i32, i32* %20
%326 = icmp slt i32 %324, %325
br i1 %326, label %327, label %339
327: ; preds = %323
%328 = load i8*, i8** %10
%329 = load i32, i32* %18
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds i8, i8* %328, i64 %330
%332 = load i8, i8* %331
%333 = load i8*, i8** %23
%334 = load i32, i32* %18
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds i8, i8* %333, i64 %335
store i8 %332, i8* %336
%337 = sext i8 %332 to i32
%338 = icmp ne i32 %337, 0
br label %339
339: ; preds = %327, %323
%340 = phi i1 [ false, %323 ], [ %338, %327 ]
br i1 %340, label %341, label %345
341: ; preds = %339
br label %342
342: ; preds = %341
%343 = load i32, i32* %18
%344 = add nsw i32 %343, 1
store i32 %344, i32* %18
br label %323
345: ; preds = %339
%346 = load i32, i32* %18
%347 = add nsw i32 %346, 1
store i32 %347, i32* %18
br label %348
348: ; preds = %362, %345
%349 = load i8*, i8** %10
%350 = load i32, i32* %18
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i8, i8* %349, i64 %351
%353 = load i8, i8* %352
%354 = load i8*, i8** %23
%355 = load i32, i32* %18
%356 = sub nsw i32 %355, 1
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i8, i8* %354, i64 %357
store i8 %353, i8* %358
%359 = sext i8 %353 to i32
%360 = icmp ne i32 %359, 0
br i1 %360, label %361, label %365
361: ; preds = %348
br label %362
362: ; preds = %361
%363 = load i32, i32* %18
%364 = add nsw i32 %363, 1
store i32 %364, i32* %18
br label %348
365: ; preds = %348
%366 = load i8*, i8** %24
%367 = call i32 @free(i8* %366)
%368 = load i8*, i8** %23
%369 = load i8*, i8** %11
%370 = getelementptr inbounds i8, i8* %369, i32 1
store i8* %370, i8** %11
%371 = load i8*, i8** %12
%372 = getelementptr inbounds i8, i8* %371, i32 1
store i8* %372, i8** %12
%373 = load i8*, i8** %13
%374 = load i8*, i8** %14
%375 = load i8*, i8** %15
%376 = load i32*, i32** %16
%377 = load i32*, i32** %17
%378 = call i32 @e_p_comp_mess(i8* %368, i8* %370, i8* %372, i8* %373, i8* %374, i8* %375, i32* %376, i32* %377)
store i32 %378, i32* %19
%379 = load i8*, i8** %23
%380 = call i32 @free(i8* %379)
%381 = load i32, i32* %19
store i32 %381, i32* %9
br label %980
382: ; preds = %307
%383 = load i8*, i8** %10
%384 = load i32, i32* %20
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds i8, i8* %383, i64 %385
%387 = load i8, i8* %386
%388 = sext i8 %387 to i32
%389 = icmp eq i32 %388, 91
br i1 %389, label %390, label %483
390: ; preds = %382
store i32 0, i32* %18
br label %391
391: ; preds = %423, %390
%392 = load i8*, i8** %11
%393 = load i32, i32* %18
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds i8, i8* %392, i64 %394
%396 = load i8, i8* %395
%397 = sext i8 %396 to i32
%398 = icmp ne i32 %397, 0
br i1 %398, label %399, label %420
399: ; preds = %391
%400 = load i8*, i8** %10
%401 = load i32, i32* %20
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds i8, i8* %400, i64 %402
%404 = load i8*, i8** %11
%405 = load i32, i32* %18
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds i8, i8* %404, i64 %406
%408 = load i8*, i8** %12
%409 = load i32, i32* %18
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds i8, i8* %408, i64 %410
%412 = load i8*, i8** %13
%413 = load i8*, i8** %14
%414 = load i8*, i8** %15
%415 = load i32*, i32** %16
%416 = load i32*, i32** %17
%417 = call i32 @e_p_comp_mess(i8* %403, i8* %407, i8* %411, i8* %412, i8* %413, i8* %414, i32* %415, i32* %416)
store i32 %417, i32* %19
%418 = icmp ne i32 %417, 0
%419 = xor i1 %418, true
br label %420
420: ; preds = %399, %391
%421 = phi i1 [ false, %391 ], [ %419, %399 ]
br i1 %421, label %422, label %426
422: ; preds = %420
br label %423
423: ; preds = %422
%424 = load i32, i32* %18
%425 = add nsw i32 %424, 1
store i32 %425, i32* %18
br label %391
426: ; preds = %420
%427 = load i8*, i8** %11
%428 = load i32, i32* %18
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i8, i8* %427, i64 %429
%431 = load i8, i8* %430
%432 = icmp ne i8 %431, 0
br i1 %432, label %434, label %433
433: ; preds = %426
store i32 0, i32* %9
br label %980
434: ; preds = %426
%435 = load i8*, i8** %10
%436 = getelementptr inbounds i8, i8* %435, i64 0
%437 = load i8, i8* %436
%438 = sext i8 %437 to i32
%439 = icmp eq i32 %438, 36
br i1 %439, label %440, label %481
440: ; preds = %434
%441 = load i32, i32* %18
%442 = add nsw i32 %441, 1
%443 = sext i32 %442 to i64
%444 = mul i64 %443, 1
%445 = trunc i64 %444 to i32
%446 = call i8* @malloc(i32 %445)
store i8* %446, i8** %25
store i32 0, i32* %20
br label %447
447: ; preds = %461, %440
%448 = load i32, i32* %20
%449 = load i32, i32* %18
%450 = icmp slt i32 %448, %449
br i1 %450, label %451, label %464
451: ; preds = %447
%452 = load i8*, i8** %11
%453 = load i32, i32* %20
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds i8, i8* %452, i64 %454
%456 = load i8, i8* %455
%457 = load i8*, i8** %25
%458 = load i32, i32* %20
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds i8, i8* %457, i64 %459
store i8 %456, i8* %460
br label %461
461: ; preds = %451
%462 = load i32, i32* %20
%463 = add nsw i32 %462, 1
store i32 %463, i32* %20
br label %447
464: ; preds = %447
%465 = load i8*, i8** %25
%466 = load i32, i32* %18
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds i8, i8* %465, i64 %467
store i8 0, i8* %468
%469 = load i8*, i8** %24
%470 = load i8*, i8** %25
%471 = load i8*, i8** %13
%472 = load i8*, i8** %14
%473 = load i8*, i8** %15
%474 = load i32*, i32** %16
%475 = load i32*, i32** %17
%476 = call i32 @e_p_konv_mess(i8* %469, i8* %470, i8* %471, i8* %472, i8* %473, i32* %474, i32* %475)
%477 = load i8*, i8** %24
%478 = call i32 @free(i8* %477)
%479 = load i8*, i8** %25
%480 = call i32 @free(i8* %479)
br label %481
481: ; preds = %464, %434
%482 = load i32, i32* %19
store i32 %482, i32* %9
br label %980
483: ; preds = %382
%484 = load i32, i32* %20
%485 = load i32, i32* %19
%486 = sub nsw i32 %485, %484
store i32 %486, i32* %19
%487 = load i32, i32* %19
%488 = add nsw i32 %487, 1
%489 = call i8* @malloc(i32 %488)
store i8* %489, i8** %22
store i32 0, i32* %18
br label %490
490: ; preds = %506, %483
%491 = load i32, i32* %18
%492 = load i32, i32* %19
%493 = icmp slt i32 %491, %492
br i1 %493, label %494, label %509
494: ; preds = %490
%495 = load i8*, i8** %10
%496 = load i32, i32* %18
%497 = load i32, i32* %20
%498 = add nsw i32 %496, %497
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds i8, i8* %495, i64 %499
%501 = load i8, i8* %500
%502 = load i8*, i8** %22
%503 = load i32, i32* %18
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds i8, i8* %502, i64 %504
store i8 %501, i8* %505
br label %506
506: ; preds = %494
%507 = load i32, i32* %18
%508 = add nsw i32 %507, 1
store i32 %508, i32* %18
br label %490
509: ; preds = %490
%510 = load i8*, i8** %22
%511 = load i32, i32* %19
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds i8, i8* %510, i64 %512
store i8 0, i8* %513
%514 = load i8*, i8** %11
%515 = load i8*, i8** %22
%516 = call i8* @strstr(i8* %514, i8* %515)
store i8* %516, i8** %23
%517 = load i8*, i8** %22
%518 = call i32 @free(i8* %517)
%519 = load i8*, i8** %23
%520 = icmp eq i8* %519, null
br i1 %520, label %521, label %522
521: ; preds = %509
store i32 0, i32* %9
br label %980
522: ; preds = %509
%523 = load i8*, i8** %10
%524 = getelementptr inbounds i8, i8* %523, i64 0
%525 = load i8, i8* %524
%526 = sext i8 %525 to i32
%527 = icmp eq i32 %526, 36
br i1 %527, label %528, label %588
528: ; preds = %522
store i32 0, i32* %18
br label %529
529: ; preds = %537, %528
%530 = load i8*, i8** %12
%531 = load i32, i32* %18
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds i8, i8* %530, i64 %532
%534 = load i8*, i8** %23
%535 = icmp ult i8* %533, %534
br i1 %535, label %536, label %540
536: ; preds = %529
br label %537
537: ; preds = %536
%538 = load i32, i32* %18
%539 = add nsw i32 %538, 1
store i32 %539, i32* %18
br label %529
540: ; preds = %529
%541 = load i32, i32* %18
%542 = add nsw i32 %541, 1
%543 = sext i32 %542 to i64
%544 = mul i64 %543, 1
%545 = trunc i64 %544 to i32
%546 = call i8* @malloc(i32 %545)
store i8* %546, i8** %25
store i32 0, i32* %18
br label %547
547: ; preds = %564, %540
%548 = load i8*, i8** %12
%549 = load i32, i32* %18
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds i8, i8* %548, i64 %550
%552 = load i8*, i8** %23
%553 = icmp ult i8* %551, %552
br i1 %553, label %554, label %567
554: ; preds = %547
%555 = load i8*, i8** %12
%556 = load i32, i32* %18
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds i8, i8* %555, i64 %557
%559 = load i8, i8* %558
%560 = load i8*, i8** %25
%561 = load i32, i32* %18
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds i8, i8* %560, i64 %562
store i8 %559, i8* %563
br label %564
564: ; preds = %554
%565 = load i32, i32* %18
%566 = add nsw i32 %565, 1
store i32 %566, i32* %18
br label %547
567: ; preds = %547
%568 = load i8*, i8** %25
%569 = load i32, i32* %18
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds i8, i8* %568, i64 %570
store i8 0, i8* %571
%572 = load i8*, i8** %24
%573 = load i8*, i8** %25
%574 = load i8*, i8** %13
%575 = load i8*, i8** %14
%576 = load i8*, i8** %15
%577 = load i32*, i32** %16
%578 = load i32*, i32** %17
%579 = call i32 @e_p_konv_mess(i8* %572, i8* %573, i8* %574, i8* %575, i8* %576, i32* %577, i32* %578)
store i32 %579, i32* %18
%580 = load i8*, i8** %24
%581 = call i32 @free(i8* %580)
%582 = load i8*, i8** %25
%583 = call i32 @free(i8* %582)
%584 = load i32, i32* %18
%585 = icmp ne i32 %584, 0
br i1 %585, label %586, label %587
586: ; preds = %567
store i32 0, i32* %9
br label %980
587: ; preds = %567
br label %588
588: ; preds = %587, %522
%589 = load i8*, i8** %10
%590 = load i32, i32* %20
%591 = load i32, i32* %19
%592 = add nsw i32 %590, %591
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds i8, i8* %589, i64 %593
%595 = load i8, i8* %594
%596 = icmp ne i8 %595, 0
br i1 %596, label %605, label %597
597: ; preds = %588
%598 = load i8*, i8** %23
%599 = load i32, i32* %19
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds i8, i8* %598, i64 %600
%602 = load i8, i8* %601
%603 = icmp ne i8 %602, 0
br i1 %603, label %605, label %604
604: ; preds = %597
store i32 2, i32* %9
br label %980
605: ; preds = %597, %588
%606 = load i8*, i8** %10
%607 = load i32, i32* %20
%608 = load i32, i32* %19
%609 = add nsw i32 %607, %608
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds i8, i8* %606, i64 %610
%612 = load i8, i8* %611
%613 = icmp ne i8 %612, 0
br i1 %613, label %626, label %614
614: ; preds = %605
%615 = load i8*, i8** %10
%616 = load i8*, i8** %23
%617 = getelementptr inbounds i8, i8* %616, i64 1
%618 = load i8*, i8** %23
%619 = getelementptr inbounds i8, i8* %618, i64 1
%620 = load i8*, i8** %13
%621 = load i8*, i8** %14
%622 = load i8*, i8** %15
%623 = load i32*, i32** %16
%624 = load i32*, i32** %17
%625 = call i32 @e_p_comp_mess(i8* %615, i8* %617, i8* %619, i8* %620, i8* %621, i8* %622, i32* %623, i32* %624)
store i32 %625, i32* %9
br label %980
626: ; preds = %605
%627 = load i8*, i8** %10
%628 = load i32, i32* %20
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds i8, i8* %627, i64 %629
%631 = load i32, i32* %19
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds i8, i8* %630, i64 %632
%634 = load i8*, i8** %23
%635 = load i32, i32* %19
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds i8, i8* %634, i64 %636
%638 = load i8*, i8** %23
%639 = load i32, i32* %19
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds i8, i8* %638, i64 %640
%642 = load i8*, i8** %13
%643 = load i8*, i8** %14
%644 = load i8*, i8** %15
%645 = load i32*, i32** %16
%646 = load i32*, i32** %17
%647 = call i32 @e_p_comp_mess(i8* %633, i8* %637, i8* %641, i8* %642, i8* %643, i8* %644, i32* %645, i32* %646)
store i32 %647, i32* %18
%648 = icmp ne i32 %647, 0
br i1 %648, label %649, label %651
649: ; preds = %626
%650 = load i32, i32* %18
store i32 %650, i32* %9
br label %980
651: ; preds = %626
%652 = load i8*, i8** %14
%653 = getelementptr inbounds i8, i8* %652, i64 0
%654 = load i8, i8* %653
%655 = sext i8 %654 to i32
%656 = icmp ne i32 %655, 0
br i1 %656, label %657, label %662
657: ; preds = %651
%658 = load i32*, i32** %16
%659 = load i32, i32* %658
%660 = icmp sgt i32 %659, -1
br i1 %660, label %661, label %662
661: ; preds = %657
store i32 0, i32* %9
br label %980
662: ; preds = %657, %651
%663 = load i8*, i8** %10
%664 = load i8*, i8** %23
%665 = getelementptr inbounds i8, i8* %664, i64 1
%666 = load i8*, i8** %10
%667 = getelementptr inbounds i8, i8* %666, i64 0
%668 = load i8, i8* %667
%669 = sext i8 %668 to i32
%670 = icmp eq i32 %669, 36
br i1 %670, label %671, label %673
671: ; preds = %662
%672 = load i8*, i8** %12
br label %676
673: ; preds = %662
%674 = load i8*, i8** %23
%675 = getelementptr inbounds i8, i8* %674, i64 1
br label %676
676: ; preds = %673, %671
%677 = phi i8* [ %672, %671 ], [ %675, %673 ]
%678 = load i8*, i8** %13
%679 = load i8*, i8** %14
%680 = load i8*, i8** %15
%681 = load i32*, i32** %16
%682 = load i32*, i32** %17
%683 = call i32 @e_p_comp_mess(i8* %663, i8* %665, i8* %677, i8* %678, i8* %679, i8* %680, i32* %681, i32* %682)
store i32 %683, i32* %9
br label %980
684: ; preds = %301
%685 = load i8*, i8** %10
%686 = getelementptr inbounds i8, i8* %685, i64 0
%687 = load i8, i8* %686
%688 = sext i8 %687 to i32
%689 = icmp eq i32 %688, 63
br i1 %689, label %690, label %697
690: ; preds = %684
%691 = load i32, i32* %19
%692 = add nsw i32 %691, -1
store i32 %692, i32* %19
%693 = load i8*, i8** %10
%694 = getelementptr inbounds i8, i8* %693, i32 1
store i8* %694, i8** %10
%695 = load i8*, i8** %11
%696 = getelementptr inbounds i8, i8* %695, i32 1
store i8* %696, i8** %11
br label %940
697: ; preds = %684
%698 = load i8*, i8** %10
%699 = getelementptr inbounds i8, i8* %698, i64 0
%700 = load i8, i8* %699
%701 = sext i8 %700 to i32
%702 = icmp eq i32 %701, 91
br i1 %702, label %703, label %939
703: ; preds = %697
%704 = load i8*, i8** %10
%705 = getelementptr inbounds i8, i8* %704, i64 1
%706 = load i8, i8* %705
%707 = sext i8 %706 to i32
%708 = icmp eq i32 %707, 33
br i1 %708, label %709, label %813
709: ; preds = %703
store i32 2, i32* %20
br label %710
710: ; preds = %784, %709
%711 = load i8*, i8** %10
%712 = load i32, i32* %20
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds i8, i8* %711, i64 %713
%715 = load i8, i8* %714
%716 = sext i8 %715 to i32
%717 = icmp ne i32 %716, 0
br i1 %717, label %718, label %741
718: ; preds = %710
%719 = load i8*, i8** %10
%720 = load i32, i32* %20
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds i8, i8* %719, i64 %721
%723 = load i8, i8* %722
%724 = sext i8 %723 to i32
%725 = icmp ne i32 %724, 93
br i1 %725, label %729, label %726
726: ; preds = %718
%727 = load i32, i32* %20
%728 = icmp eq i32 %727, 2
br i1 %728, label %729, label %741
729: ; preds = %726, %718
%730 = load i8*, i8** %10
%731 = load i32, i32* %20
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds i8, i8* %730, i64 %732
%734 = load i8, i8* %733
%735 = sext i8 %734 to i32
%736 = load i8*, i8** %11
%737 = getelementptr inbounds i8, i8* %736, i64 0
%738 = load i8, i8* %737
%739 = sext i8 %738 to i32
%740 = icmp ne i32 %735, %739
br label %741
741: ; preds = %729, %726, %710
%742 = phi i1 [ false, %726 ], [ false, %710 ], [ %740, %729 ]
br i1 %742, label %743, label %787
743: ; preds = %741
%744 = load i8*, i8** %10
%745 = load i32, i32* %20
%746 = add nsw i32 %745, 1
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds i8, i8* %744, i64 %747
%749 = load i8, i8* %748
%750 = sext i8 %749 to i32
%751 = icmp eq i32 %750, 45
br i1 %751, label %752, label %783
752: ; preds = %743
%753 = load i8*, i8** %11
%754 = getelementptr inbounds i8, i8* %753, i64 0
%755 = load i8, i8* %754
%756 = sext i8 %755 to i32
%757 = load i8*, i8** %10
%758 = load i32, i32* %20
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds i8, i8* %757, i64 %759
%761 = load i8, i8* %760
%762 = sext i8 %761 to i32
%763 = icmp sge i32 %756, %762
br i1 %763, label %764, label %783
764: ; preds = %752
%765 = load i8*, i8** %11
%766 = getelementptr inbounds i8, i8* %765, i64 0
%767 = load i8, i8* %766
%768 = sext i8 %767 to i32
%769 = load i8*, i8** %10
%770 = load i32, i32* %20
%771 = add nsw i32 %770, 2
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds i8, i8* %769, i64 %772
%774 = load i8, i8* %773
%775 = sext i8 %774 to i32
%776 = icmp sle i32 %768, %775
br i1 %776, label %777, label %783
777: ; preds = %764
%778 = load i8*, i8** %11
%779 = getelementptr inbounds i8, i8* %778, i64 0
%780 = load i8, i8* %779
%781 = sext i8 %780 to i32
%782 = sub nsw i32 0, %781
store i32 %782, i32* %9
br label %980
783: ; preds = %764, %752, %743
br label %784
784: ; preds = %783
%785 = load i32, i32* %20
%786 = add nsw i32 %785, 1
store i32 %786, i32* %20
br label %710
787: ; preds = %741
%788 = load i8*, i8** %10
%789 = load i32, i32* %20
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds i8, i8* %788, i64 %790
%792 = load i8, i8* %791
%793 = sext i8 %792 to i32
%794 = icmp ne i32 %793, 93
br i1 %794, label %795, label %801
795: ; preds = %787
%796 = load i8*, i8** %11
%797 = getelementptr inbounds i8, i8* %796, i64 0
%798 = load i8, i8* %797
%799 = sext i8 %798 to i32
%800 = sub nsw i32 0, %799
store i32 %800, i32* %9
br label %980
801: ; preds = %787
%802 = load i32, i32* %20
%803 = add nsw i32 %802, 1
%804 = load i32, i32* %19
%805 = sub nsw i32 %804, %803
store i32 %805, i32* %19
%806 = load i32, i32* %20
%807 = add nsw i32 %806, 1
%808 = load i8*, i8** %10
%809 = sext i32 %807 to i64
%810 = getelementptr inbounds i8, i8* %808, i64 %809
store i8* %810, i8** %10
%811 = load i8*, i8** %11
%812 = getelementptr inbounds i8, i8* %811, i32 1
store i8* %812, i8** %11
br label %938
813: ; preds = %703
store i32 1, i32* %20
br label %814
814: ; preds = %883, %813
%815 = load i8*, i8** %10
%816 = load i32, i32* %20
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds i8, i8* %815, i64 %817
%819 = load i8, i8* %818
%820 = sext i8 %819 to i32
%821 = icmp ne i32 %820, 0
br i1 %821, label %822, label %845
822: ; preds = %814
%823 = load i8*, i8** %10
%824 = load i32, i32* %20
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds i8, i8* %823, i64 %825
%827 = load i8, i8* %826
%828 = sext i8 %827 to i32
%829 = icmp ne i32 %828, 93
br i1 %829, label %833, label %830
830: ; preds = %822
%831 = load i32, i32* %20
%832 = icmp eq i32 %831, 1
br i1 %832, label %833, label %845
833: ; preds = %830, %822
%834 = load i8*, i8** %10
%835 = load i32, i32* %20
%836 = sext i32 %835 to i64
%837 = getelementptr inbounds i8, i8* %834, i64 %836
%838 = load i8, i8* %837
%839 = sext i8 %838 to i32
%840 = load i8*, i8** %11
%841 = getelementptr inbounds i8, i8* %840, i64 0
%842 = load i8, i8* %841
%843 = sext i8 %842 to i32
%844 = icmp ne i32 %839, %843
br label %845
845: ; preds = %833, %830, %814
%846 = phi i1 [ false, %830 ], [ false, %814 ], [ %844, %833 ]
br i1 %846, label %847, label %886
847: ; preds = %845
%848 = load i8*, i8** %10
%849 = load i32, i32* %20
%850 = add nsw i32 %849, 1
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds i8, i8* %848, i64 %851
%853 = load i8, i8* %852
%854 = sext i8 %853 to i32
%855 = icmp eq i32 %854, 45
br i1 %855, label %856, label %882
856: ; preds = %847
%857 = load i8*, i8** %11
%858 = getelementptr inbounds i8, i8* %857, i64 0
%859 = load i8, i8* %858
%860 = sext i8 %859 to i32
%861 = load i8*, i8** %10
%862 = load i32, i32* %20
%863 = sext i32 %862 to i64
%864 = getelementptr inbounds i8, i8* %861, i64 %863
%865 = load i8, i8* %864
%866 = sext i8 %865 to i32
%867 = icmp sge i32 %860, %866
br i1 %867, label %868, label %882
868: ; preds = %856
%869 = load i8*, i8** %11
%870 = getelementptr inbounds i8, i8* %869, i64 0
%871 = load i8, i8* %870
%872 = sext i8 %871 to i32
%873 = load i8*, i8** %10
%874 = load i32, i32* %20
%875 = add nsw i32 %874, 2
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds i8, i8* %873, i64 %876
%878 = load i8, i8* %877
%879 = sext i8 %878 to i32
%880 = icmp sle i32 %872, %879
br i1 %880, label %881, label %882
881: ; preds = %868
br label %886
882: ; preds = %868, %856, %847
br label %883
883: ; preds = %882
%884 = load i32, i32* %20
%885 = add nsw i32 %884, 1
store i32 %885, i32* %20
br label %814
886: ; preds = %881, %845
%887 = load i8*, i8** %10
%888 = load i32, i32* %20
%889 = sext i32 %888 to i64
%890 = getelementptr inbounds i8, i8* %887, i64 %889
%891 = load i8, i8* %890
%892 = sext i8 %891 to i32
%893 = icmp eq i32 %892, 93
br i1 %893, label %902, label %894
894: ; preds = %886
%895 = load i8*, i8** %10
%896 = load i32, i32* %20
%897 = sext i32 %896 to i64
%898 = getelementptr inbounds i8, i8* %895, i64 %897
%899 = load i8, i8* %898
%900 = sext i8 %899 to i32
%901 = icmp eq i32 %900, 0
br i1 %901, label %902, label %903
902: ; preds = %894, %886
store i32 0, i32* %9
br label %980
903: ; preds = %894
br label %904
904: ; preds = %923, %903
%905 = load i8*, i8** %10
%906 = load i32, i32* %20
%907 = sext i32 %906 to i64
%908 = getelementptr inbounds i8, i8* %905, i64 %907
%909 = load i8, i8* %908
%910 = sext i8 %909 to i32
%911 = icmp ne i32 %910, 0
br i1 %911, label %912, label %920
912: ; preds = %904
%913 = load i8*, i8** %10
%914 = load i32, i32* %20
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds i8, i8* %913, i64 %915
%917 = load i8, i8* %916
%918 = sext i8 %917 to i32
%919 = icmp ne i32 %918, 93
br label %920
920: ; preds = %912, %904
%921 = phi i1 [ false, %904 ], [ %919, %912 ]
br i1 %921, label %922, label %926
922: ; preds = %920
br label %923
923: ; preds = %922
%924 = load i32, i32* %20
%925 = add nsw i32 %924, 1
store i32 %925, i32* %20
br label %904
926: ; preds = %920
%927 = load i32, i32* %20
%928 = add nsw i32 %927, 1
%929 = load i32, i32* %19
%930 = sub nsw i32 %929, %928
store i32 %930, i32* %19
%931 = load i32, i32* %20
%932 = add nsw i32 %931, 1
%933 = load i8*, i8** %10
%934 = sext i32 %932 to i64
%935 = getelementptr inbounds i8, i8* %933, i64 %934
store i8* %935, i8** %10
%936 = load i8*, i8** %11
%937 = getelementptr inbounds i8, i8* %936, i32 1
store i8* %937, i8** %11
br label %938
938: ; preds = %926, %801
br label %939
939: ; preds = %938, %697
br label %940
940: ; preds = %939, %690
br label %941
941: ; preds = %940
%942 = load i32, i32* %19
%943 = icmp sle i32 %942, 0
br i1 %943, label %944, label %954
944: ; preds = %941
%945 = load i8*, i8** %10
%946 = load i8*, i8** %11
%947 = load i8*, i8** %12
%948 = load i8*, i8** %13
%949 = load i8*, i8** %14
%950 = load i8*, i8** %15
%951 = load i32*, i32** %16
%952 = load i32*, i32** %17
%953 = call i32 @e_p_comp_mess(i8* %945, i8* %946, i8* %947, i8* %948, i8* %949, i8* %950, i32* %951, i32* %952)
store i32 %953, i32* %9
br label %980
954: ; preds = %941
%955 = load i8*, i8** %10
%956 = load i8*, i8** %11
%957 = load i32, i32* %19
%958 = call i32 @strncmp(i8* %955, i8* %956, i32 %957)
store i32 %958, i32* %20
%959 = icmp ne i32 %958, 0
br i1 %959, label %960, label %961
960: ; preds = %954
store i32 0, i32* %9
br label %980
961: ; preds = %954
%962 = load i8*, i8** %10
%963 = load i32, i32* %19
%964 = sext i32 %963 to i64
%965 = getelementptr inbounds i8, i8* %962, i64 %964
%966 = load i8*, i8** %11
%967 = load i32, i32* %19
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds i8, i8* %966, i64 %968
%970 = load i8*, i8** %12
%971 = load i32, i32* %19
%972 = sext i32 %971 to i64
%973 = getelementptr inbounds i8, i8* %970, i64 %972
%974 = load i8*, i8** %13
%975 = load i8*, i8** %14
%976 = load i8*, i8** %15
%977 = load i32*, i32** %16
%978 = load i32*, i32** %17
%979 = call i32 @e_p_comp_mess(i8* %965, i8* %969, i8* %973, i8* %974, i8* %975, i8* %976, i32* %977, i32* %978)
store i32 %979, i32* %9
br label %980
980: ; preds = %961, %960, %944, %902, %795, %777, %676, %661, %649, %614, %604, %586, %521, %481, %433, %365, %175, %82, %63, %52, %41, %29
%981 = load i32, i32* %9
ret i32 %981
}

LLVM IR (-O2):
define i32 @e_p_comp_mess(i8* %0, i8* %1, i8* %2, i8* %3, i8* %4, i8* %5, i32* %6, i32* %7) {
%9 = icmp ugt i8* %2, %1
br i1 %9, label %305, label %10
10: ; preds = %8, %35
%11 = phi i8* [ %38, %35 ], [ %2, %8 ]
%12 = phi i8* [ %37, %35 ], [ %1, %8 ]
%13 = phi i8* [ %36, %35 ], [ %0, %8 ]
%14 = getelementptr inbounds i8, i8* %13, i64 1
%15 = getelementptr i8, i8* %13, i64 2
br label %16
16: ; preds = %10, %746
%17 = phi i8* [ %11, %10 ], [ %748, %746 ]
%18 = phi i8* [ %12, %10 ], [ %747, %746 ]
%19 = ptrtoint i8* %17 to i64
%20 = load i8, i8* %13
switch i8 %20, label %31 [
i8 42, label %21
i8 0, label %24
]
21: ; preds = %16
%22 = load i8, i8* %14
%23 = icmp eq i8 %22, 0
br i1 %23, label %305, label %28
24: ; preds = %16
%25 = load i8, i8* %18
%26 = icmp eq i8 %25, 0
%27 = select i1 %26, i32 2, i32 0
br label %305
28: ; preds = %21
%29 = load i8, i8* %18
%30 = icmp eq i8 %29, 0
br i1 %30, label %305, label %34
31: ; preds = %16
%32 = load i8, i8* %18
%33 = icmp eq i8 %32, 0
br i1 %33, label %305, label %40
34: ; preds = %28
switch i8 %22, label %236 [
i8 42, label %35
i8 36, label %35
]
35: ; preds = %34, %34, %864, %856
%36 = phi i8* [ %858, %856 ], [ %866, %864 ], [ %14, %34 ], [ %14, %34 ]
%37 = phi i8* [ %857, %856 ], [ %867, %864 ], [ %18, %34 ], [ %18, %34 ]
%38 = phi i8* [ %17, %856 ], [ %868, %864 ], [ %17, %34 ], [ %17, %34 ]
%39 = icmp ugt i8* %38, %37
br i1 %39, label %305, label %10
40: ; preds = %31
%41 = icmp eq i8 %20, 36
br i1 %41, label %42, label %239
42: ; preds = %40
%43 = load i8, i8* %14
%44 = icmp eq i8 %43, 123
br i1 %44, label %45, label %239
45: ; preds = %42, %49
%46 = phi i64 [ %50, %49 ], [ 2, %42 ]
%47 = getelementptr inbounds i8, i8* %13, i64 %46
%48 = load i8, i8* %47
switch i8 %48, label %49 [
i8 0, label %51
i8 125, label %51
]
49: ; preds = %45
%50 = add nuw i64 %46, 1
br label %45
51: ; preds = %45, %45
%52 = trunc i64 %46 to i32
%53 = add nsw i32 %52, -1
%54 = tail call i8* @malloc(i32 %53)
%55 = icmp ugt i32 %52, 2
br i1 %55, label %56, label %216
56: ; preds = %51
%57 = and i64 %46, 4294967295
%58 = add nsw i64 %57, -2
%59 = icmp ult i64 %58, 8
br i1 %59, label %175, label %60
60: ; preds = %56
%61 = getelementptr i8, i8* %54, i64 -2
%62 = getelementptr i8, i8* %61, i64 %57
%63 = getelementptr i8, i8* %13, i64 %57
%64 = icmp ult i8* %54, %63
%65 = icmp ult i8* %15, %62
%66 = and i1 %64, %65
br i1 %66, label %175, label %67
67: ; preds = %60
%68 = icmp ult i64 %58, 32
br i1 %68, label %157, label %69
69: ; preds = %67
%70 = and i64 %58, -32
%71 = add nsw i64 %70, -32
%72 = lshr exact i64 %71, 5
%73 = add nuw nsw i64 %72, 1
%74 = and i64 %73, 3
%75 = icmp ult i64 %71, 96
br i1 %75, label %131, label %76
76: ; preds = %69
%77 = and i64 %73, 1152921504606846972
br label %78
78: ; preds = %78, %76
%79 = phi i64 [ 0, %76 ], [ %128, %78 ]
%80 = phi i64 [ 0, %76 ], [ %129, %78 ]
%81 = or i64 %79, 2
%82 = getelementptr inbounds i8, i8* %13, i64 %81
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = getelementptr inbounds i8, i8* %82, i64 16
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = getelementptr inbounds i8, i8* %54, i64 %79
%89 = bitcast i8* %88 to <16 x i8>*
store <16 x i8> %84, <16 x i8>* %89
%90 = getelementptr inbounds i8, i8* %88, i64 16
%91 = bitcast i8* %90 to <16 x i8>*
store <16 x i8> %87, <16 x i8>* %91
%92 = or i64 %79, 32
%93 = or i64 %79, 34
%94 = getelementptr inbounds i8, i8* %13, i64 %93
%95 = bitcast i8* %94 to <16 x i8>*
%96 = load <16 x i8>, <16 x i8>* %95
%97 = getelementptr inbounds i8, i8* %94, i64 16
%98 = bitcast i8* %97 to <16 x i8>*
%99 = load <16 x i8>, <16 x i8>* %98
%100 = getelementptr inbounds i8, i8* %54, i64 %92
%101 = bitcast i8* %100 to <16 x i8>*
store <16 x i8> %96, <16 x i8>* %101
%102 = getelementptr inbounds i8, i8* %100, i64 16
%103 = bitcast i8* %102 to <16 x i8>*
store <16 x i8> %99, <16 x i8>* %103
%104 = or i64 %79, 64
%105 = or i64 %79, 66
%106 = getelementptr inbounds i8, i8* %13, 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* %54, i64 %104
%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 %79, 96
%117 = or i64 %79, 98
%118 = getelementptr inbounds i8, i8* %13, i64 %117
%119 = bitcast i8* %118 to <16 x i8>*
%120 = load <16 x i8>, <16 x i8>* %119
%121 = getelementptr inbounds i8, i8* %118, i64 16
%122 = bitcast i8* %121 to <16 x i8>*
%123 = load <16 x i8>, <16 x i8>* %122
%124 = getelementptr inbounds i8, i8* %54, i64 %116
%125 = bitcast i8* %124 to <16 x i8>*
store <16 x i8> %120, <16 x i8>* %125
%126 = getelementptr inbounds i8, i8* %124, i64 16
%127 = bitcast i8* %126 to <16 x i8>*
store <16 x i8> %123, <16 x i8>* %127
%128 = add nuw i64 %79, 128
%129 = add i64 %80, 4
%130 = icmp eq i64 %129, %77
br i1 %130, label %131, label %78
131: ; preds = %78, %69
%132 = phi i64 [ 0, %69 ], [ %128, %78 ]
%133 = icmp eq i64 %74, 0
br i1 %133, label %151, label %134
134: ; preds = %131, %134
%135 = phi i64 [ %148, %134 ], [ %132, %131 ]
%136 = phi i64 [ %149, %134 ], [ 0, %131 ]
%137 = or i64 %135, 2
%138 = getelementptr inbounds i8, i8* %13, i64 %137
%139 = bitcast i8* %138 to <16 x i8>*
%140 = load <16 x i8>, <16 x i8>* %139
%141 = getelementptr inbounds i8, i8* %138, i64 16
%142 = bitcast i8* %141 to <16 x i8>*
%143 = load <16 x i8>, <16 x i8>* %142
%144 = getelementptr inbounds i8, i8* %54, i64 %135
%145 = bitcast i8* %144 to <16 x i8>*
store <16 x i8> %140, <16 x i8>* %145
%146 = getelementptr inbounds i8, i8* %144, i64 16
%147 = bitcast i8* %146 to <16 x i8>*
store <16 x i8> %143, <16 x i8>* %147
%148 = add nuw i64 %135, 32
%149 = add i64 %136, 1
%150 = icmp eq i64 %149, %74
br i1 %150, label %151, label %134
151: ; preds = %134, %131
%152 = icmp eq i64 %58, %70
br i1 %152, label %216, label %153
153: ; preds = %151
%154 = or i64 %70, 2
%155 = and i64 %58, 24
%156 = icmp eq i64 %155, 0
br i1 %156, label %175, label %157
157: ; preds = %67, %153
%158 = phi i64 [ %70, %153 ], [ 0, %67 ]
%159 = and i64 %46, 4294967295
%160 = add nsw i64 %159, -2
%161 = and i64 %160, -8
%162 = or i64 %161, 2
br label %163
163: ; preds = %163, %157
%164 = phi i64 [ %158, %157 ], [ %171, %163 ]
%165 = or i64 %164, 2
%166 = getelementptr inbounds i8, i8* %13, i64 %165
%167 = bitcast i8* %166 to <8 x i8>*
%168 = load <8 x i8>, <8 x i8>* %167
%169 = getelementptr inbounds i8, i8* %54, i64 %164
%170 = bitcast i8* %169 to <8 x i8>*
store <8 x i8> %168, <8 x i8>* %170
%171 = add nuw i64 %164, 8
%172 = icmp eq i64 %171, %161
br i1 %172, label %173, label %163
173: ; preds = %163
%174 = icmp eq i64 %160, %161
br i1 %174, label %216, label %175
175: ; preds = %60, %56, %153, %173
%176 = phi i64 [ 2, %56 ], [ 2, %60 ], [ %154, %153 ], [ %162, %173 ]
%177 = sub i64 %46, %176
%178 = xor i64 %176, -1
%179 = add nsw i64 %57, %178
%180 = and i64 %177, 3
%181 = icmp eq i64 %180, 0
br i1 %181, label %192, label %182
182: ; preds = %175, %182
%183 = phi i64 [ %189, %182 ], [ %176, %175 ]
%184 = phi i64 [ %190, %182 ], [ 0, %175 ]
%185 = getelementptr inbounds i8, i8* %13, i64 %183
%186 = load i8, i8* %185
%187 = add nsw i64 %183, -2
%188 = getelementptr inbounds i8, i8* %54, i64 %187
store i8 %186, i8* %188
%189 = add nuw nsw i64 %183, 1
%190 = add i64 %184, 1
%191 = icmp eq i64 %190, %180
br i1 %191, label %192, label %182
192: ; preds = %182, %175
%193 = phi i64 [ %176, %175 ], [ %189, %182 ]
%194 = icmp ult i64 %179, 3
br i1 %194, label %216, label %195
195: ; preds = %192, %195
%196 = phi i64 [ %214, %195 ], [ %193, %192 ]
%197 = getelementptr inbounds i8, i8* %13, i64 %196
%198 = load i8, i8* %197
%199 = add nsw i64 %196, -2
%200 = getelementptr inbounds i8, i8* %54, i64 %199
store i8 %198, i8* %200
%201 = add nuw nsw i64 %196, 1
%202 = getelementptr inbounds i8, i8* %13, i64 %201
%203 = load i8, i8* %202
%204 = add nsw i64 %196, -1
%205 = getelementptr inbounds i8, i8* %54, i64 %204
store i8 %203, i8* %205
%206 = add nuw nsw i64 %196, 2
%207 = getelementptr inbounds i8, i8* %13, i64 %206
%208 = load i8, i8* %207
%209 = getelementptr inbounds i8, i8* %54, i64 %196
store i8 %208, i8* %209
%210 = add nuw nsw i64 %196, 3
%211 = getelementptr inbounds i8, i8* %13, i64 %210
%212 = load i8, i8* %211
%213 = getelementptr inbounds i8, i8* %54, i64 %201
store i8 %212, i8* %213
%214 = add nuw nsw i64 %196, 4
%215 = icmp eq i64 %214, %57
br i1 %215, label %216, label %195
216: ; preds = %192, %195, %151, %173, %51
%217 = shl i64 %46, 32
%218 = add i64 %217, -8589934592
%219 = ashr exact i64 %218, 32
%220 = getelementptr inbounds i8, i8* %54, i64 %219
store i8 0, i8* %220
%221 = icmp ne i8 %48, 0
%222 = zext i1 %221 to i32
%223 = add nuw nsw i32 %52, %222
%224 = zext i32 %223 to i64
%225 = getelementptr inbounds i8, i8* %13, i64 %224
%226 = load i8, i8* %225
%227 = icmp eq i8 %226, 0
br i1 %227, label %228, label %232
228: ; preds = %216
%229 = tail call i32 @e_p_konv_mess(i8* %54, i8* %18, i8* %3, i8* %4, i8* %5, i32* %6, i32* %7)
%230 = icmp eq i32 %229, 0
%231 = zext i1 %230 to i32
br label %305
232: ; preds = %216
%233 = icmp ne i8 %226, 92
%234 = zext i1 %233 to i32
%235 = add nuw nsw i32 %223, %234
br label %242
236: ; preds = %34
%237 = load i8, i8* %14
%238 = icmp eq i8 %237, 92
br i1 %238, label %239, label %242
239: ; preds = %40, %42, %236
%240 = phi i8 [ %29, %236 ], [ %32, %42 ], [ %32, %40 ]
%241 = phi i1 [ false, %236 ], [ true, %42 ], [ false, %40 ]
br label %242
242: ; preds = %236, %239, %232
%243 = phi i1 [ %41, %232 ], [ %241, %239 ], [ false, %236 ]
%244 = phi i8 [ %32, %232 ], [ %240, %239 ], [ %29, %236 ]
%245 = phi i32 [ %235, %232 ], [ 1, %239 ], [ 2, %236 ]
%246 = phi i32 [ %223, %232 ], [ 0, %239 ], [ 1, %236 ]
%247 = phi i8* [ %54, %232 ], [ null, %239 ], [ null, %236 ]
%248 = sext i32 %245 to i64
br label %249
249: ; preds = %261, %242
%250 = phi i64 [ %266, %261 ], [ %248, %242 ]
%251 = phi i32 [ %265, %261 ], [ 0, %242 ]
%252 = icmp eq i32 %251, 0
%253 = getelementptr inbounds i8, i8* %13, i64 %250
%254 = load i8, i8* %253
br i1 %252, label %255, label %261
255: ; preds = %249
switch i8 %254, label %261 [
i8 0, label %267
i8 42, label %267
i8 63, label %267
i8 91, label %267
i8 36, label %256
]
256: ; preds = %255
%257 = add nsw i64 %250, 1
%258 = getelementptr inbounds i8, i8* %13, i64 %257
%259 = load i8, i8* %258
%260 = icmp eq i8 %259, 123
br i1 %260, label %267, label %261
261: ; preds = %249, %255, %256
%262 = phi i8 [ %254, %255 ], [ 36, %256 ], [ %254, %249 ]
%263 = icmp eq i8 %262, 92
%264 = select i1 %263, i1 %252, i1 false
%265 = zext i1 %264 to i32
%266 = add i64 %250, 1
br label %249
267: ; preds = %255, %255, %255, %255, %256
%268 = getelementptr inbounds i8, i8* %13, i64 %250
%269 = trunc i64 %250 to i32
switch i8 %20, label %854 [
i8 42, label %270
i8 36, label %270
i8 63, label %766
i8 91, label %770
]
270: ; preds = %267, %267
%271 = sext i32 %246 to i64
%272 = getelementptr inbounds i8, i8* %13, i64 %271
%273 = load i8, i8* %272
switch i8 %273, label %425 [
i8 63, label %277
i8 91, label %274
]
274: ; preds = %270
%275 = load i8, i8* %18
%276 = icmp eq i8 %275, 0
br i1 %276, label %305, label %313
277: ; preds = %270
%278 = tail call i32 @strlen(i8* %13)
%279 = add nsw i32 %278, 1
%280 = tail call i8* @malloc(i32 %279)
%281 = icmp sgt i32 %246, 0
br i1 %281, label %282, label %295
282: ; preds = %277
%283 = zext i32 %246 to i64
br label %284
284: ; preds = %282, %290
%285 = phi i64 [ 0, %282 ], [ %291, %290 ]
%286 = getelementptr inbounds i8, i8* %13, i64 %285
%287 = load i8, i8* %286
%288 = getelementptr inbounds i8, i8* %280, i64 %285
store i8 %287, i8* %288
%289 = icmp eq i8 %287, 0
br i1 %289, label %293, label %290
290: ; preds = %284
%291 = add nuw nsw i64 %285, 1
%292 = icmp eq i64 %291, %283
br i1 %292, label %295, label %284
293: ; preds = %284
%294 = trunc i64 %285 to i32
br label %295
295: ; preds = %290, %293, %277
%296 = phi i32 [ 0, %277 ], [ %294, %293 ], [ %246, %290 ]
%297 = zext i32 %296 to i64
br label %298
298: ; preds = %298, %295
%299 = phi i64 [ %300, %298 ], [ %297, %295 ]
%300 = add nuw nsw i64 %299, 1
%301 = getelementptr inbounds i8, i8* %13, i64 %300
%302 = load i8, i8* %301
%303 = getelementptr inbounds i8, i8* %280, i64 %299
store i8 %302, i8* %303
%304 = icmp eq i8 %302, 0
br i1 %304, label %307, label %298
305: ; preds = %770, %35, %861, %836, %31, %758, %750, %740, %729, %590, %28, %21, %746, %834, %814, %319, %8, %274, %228, %797, %804, %324, %420, %329, %24, %307
%306 = phi i32 [ %311, %307 ], [ %799, %797 ], [ %806, %804 ], [ %231, %228 ], [ 0, %324 ], [ %317, %420 ], [ %317, %329 ], [ %27, %24 ], [ 0, %274 ], [ 0, %8 ], [ 0, %319 ], [ 0, %814 ], [ 0, %834 ], [ 0, %746 ], [ 2, %21 ], [ 0, %28 ], [ 0, %590 ], [ 0, %729 ], [ 2, %740 ], [ %753, %750 ], [ 0, %758 ], [ 0, %31 ], [ 0, %836 ], [ 0, %861 ], [ 0, %35 ], [ 0, %770 ]
ret i32 %306
307: ; preds = %298
%308 = tail call i32 @free(i8* %247)
%309 = getelementptr inbounds i8, i8* %18, i64 1
%310 = getelementptr inbounds i8, i8* %17, i64 1
%311 = tail call i32 @e_p_comp_mess(i8* %280, i8* %309, i8* %310, i8* %3, i8* %4, i8* %5, i32* %6, i32* %7)
%312 = tail call i32 @free(i8* %280)
br label %305
313: ; preds = %274, %319
%314 = phi i64 [ %320, %319 ], [ 0, %274 ]
%315 = phi i8* [ %321, %319 ], [ %18, %274 ]
%316 = getelementptr inbounds i8, i8* %17, i64 %314
%317 = tail call i32 @e_p_comp_mess(i8* %272, i8* %315, i8* %316, i8* %3, i8* %4, i8* %5, i32* %6, i32* %7)
%318 = icmp eq i32 %317, 0
br i1 %318, label %319, label %324
319: ; preds = %313
%320 = add nuw i64 %314, 1
%321 = getelementptr inbounds i8, i8* %18, i64 %320
%322 = load i8, i8* %321
%323 = icmp eq i8 %322, 0
br i1 %323, label %305, label %313
324: ; preds = %313
%325 = trunc i64 %314 to i32
%326 = and i64 %314, 4294967295
%327 = load i8, i8* %315
%328 = icmp eq i8 %327, 0
br i1 %328, label %305, label %329
329: ; preds = %324
%330 = load i8, i8* %13
%331 = icmp eq i8 %330, 36
br i1 %331, label %332, label %305
332: ; preds = %329
%333 = add nuw nsw i32 %325, 1
%334 = tail call i8* @malloc(i32 %333)
%335 = icmp eq i32 %325, 0
br i1 %335, label %420, label %336
336: ; preds = %332
%337 = icmp ult i64 %326, 8
br i1 %337, label %382, label %338
338: ; preds = %336
%339 = getelementptr i8, i8* %334, i64 %326
%340 = getelementptr i8, i8* %18, i64 %326
%341 = icmp ult i8* %334, %340
%342 = icmp ult i8* %18, %339
%343 = and i1 %341, %342
br i1 %343, label %382, label %344
344: ; preds = %338
%345 = icmp ult i64 %326, 32
br i1 %345, label %367, label %346
346: ; preds = %344
%347 = and i64 %314, 31
%348 = sub nsw i64 %326, %347
br label %349
349: ; preds = %349, %346
%350 = phi i64 [ 0, %346 ], [ %361, %349 ]
%351 = getelementptr inbounds i8, i8* %18, i64 %350
%352 = bitcast i8* %351 to <16 x i8>*
%353 = load <16 x i8>, <16 x i8>* %352
%354 = getelementptr inbounds i8, i8* %351, i64 16
%355 = bitcast i8* %354 to <16 x i8>*
%356 = load <16 x i8>, <16 x i8>* %355
%357 = getelementptr inbounds i8, i8* %334, i64 %350
%358 = bitcast i8* %357 to <16 x i8>*
store <16 x i8> %353, <16 x i8>* %358
%359 = getelementptr inbounds i8, i8* %357, i64 16
%360 = bitcast i8* %359 to <16 x i8>*
store <16 x i8> %356, <16 x i8>* %360
%361 = add nuw i64 %350, 32
%362 = icmp eq i64 %361, %348
br i1 %362, label %363, label %349
363: ; preds = %349
%364 = icmp eq i64 %347, 0
br i1 %364, label %420, label %365
365: ; preds = %363
%366 = icmp ult i64 %347, 8
br i1 %366, label %382, label %367
367: ; preds = %344, %365
%368 = phi i64 [ %348, %365 ], [ 0, %344 ]
%369 = and i64 %314, 7
%370 = sub nsw i64 %326, %369
br label %371
371: ; preds = %371, %367
%372 = phi i64 [ %368, %367 ], [ %378, %371 ]
%373 = getelementptr inbounds i8, i8* %18, i64 %372
%374 = bitcast i8* %373 to <8 x i8>*
%375 = load <8 x i8>, <8 x i8>* %374
%376 = getelementptr inbounds i8, i8* %334, i64 %372
%377 = bitcast i8* %376 to <8 x i8>*
store <8 x i8> %375, <8 x i8>* %377
%378 = add nuw i64 %372, 8
%379 = icmp eq i64 %378, %370
br i1 %379, label %380, label %371
380: ; preds = %371
%381 = icmp eq i64 %369, 0
br i1 %381, label %420, label %382
382: ; preds = %338, %336, %365, %380
%383 = phi i64 [ 0, %336 ], [ 0, %338 ], [ %348, %365 ], [ %370, %380 ]
%384 = sub i64 %314, %383
%385 = xor i64 %383, -1
%386 = add nsw i64 %326, %385
%387 = and i64 %384, 3
%388 = icmp eq i64 %387, 0
br i1 %388, label %398, label %389
389: ; preds = %382, %389
%390 = phi i64 [ %395, %389 ], [ %383, %382 ]
%391 = phi i64 [ %396, %389 ], [ 0, %382 ]
%392 = getelementptr inbounds i8, i8* %18, i64 %390
%393 = load i8, i8* %392
%394 = getelementptr inbounds i8, i8* %334, i64 %390
store i8 %393, i8* %394
%395 = add nuw nsw i64 %390, 1
%396 = add i64 %391, 1
%397 = icmp eq i64 %396, %387
br i1 %397, label %398, label %389
398: ; preds = %389, %382
%399 = phi i64 [ %383, %382 ], [ %395, %389 ]
%400 = icmp ult i64 %386, 3
br i1 %400, label %420, label %401
401: ; preds = %398, %401
%402 = phi i64 [ %418, %401 ], [ %399, %398 ]
%403 = getelementptr inbounds i8, i8* %18, i64 %402
%404 = load i8, i8* %403
%405 = getelementptr inbounds i8, i8* %334, i64 %402
store i8 %404, i8* %405
%406 = add nuw nsw i64 %402, 1
%407 = getelementptr inbounds i8, i8* %18, i64 %406
%408 = load i8, i8* %407
%409 = getelementptr inbounds i8, i8* %334, i64 %406
store i8 %408, i8* %409
%410 = add nuw nsw i64 %402, 2
%411 = getelementptr inbounds i8, i8* %18, i64 %410
%412 = load i8, i8* %411
%413 = getelementptr inbounds i8, i8* %334, i64 %410
store i8 %412, i8* %413
%414 = add nuw nsw i64 %402, 3
%415 = getelementptr inbounds i8, i8* %18, i64 %414
%416 = load i8, i8* %415
%417 = getelementptr inbounds i8, i8* %334, i64 %414
store i8 %416, i8* %417
%418 = add nuw nsw i64 %402, 4
%419 = icmp eq i64 %418, %326
br i1 %419, label %420, label %401
420: ; preds = %398, %401, %363, %380, %332
%421 = getelementptr inbounds i8, i8* %334, i64 %326
store i8 0, i8* %421
%422 = tail call i32 @e_p_konv_mess(i8* %247, i8* %334, i8* %3, i8* %4, i8* %5, i32* %6, i32* %7)
%423 = tail call i32 @free(i8* %247)
%424 = tail call i32 @free(i8* %334)
br label %305
425: ; preds = %270
%426 = sub nsw i32 %269, %246
%427 = add nsw i32 %426, 1
%428 = tail call i8* @malloc(i32 %427)
%429 = icmp sgt i32 %426, 0
br i1 %429, label %430, label %590
430: ; preds = %425
%431 = zext i32 %426 to i64
%432 = icmp ult i32 %426, 8
br i1 %432, label %548, label %433
433: ; preds = %430
%434 = getelementptr i8, i8* %428, i64 %431
%435 = getelementptr i8, i8* %13, i64 %271
%436 = add nsw i64 %271, %431
%437 = getelementptr i8, i8* %13, i64 %436
%438 = icmp ult i8* %428, %437
%439 = icmp ult i8* %435, %434
%440 = and i1 %438, %439
br i1 %440, label %548, label %441
441: ; preds = %433
%442 = icmp ult i32 %426, 32
br i1 %442, label %530, label %443
443: ; preds = %441
%444 = and i64 %431, 4294967264
%445 = add nsw i64 %444, -32
%446 = lshr exact i64 %445, 5
%447 = add nuw nsw i64 %446, 1
%448 = and i64 %447, 3
%449 = icmp ult i64 %445, 96
br i1 %449, label %505, label %450
450: ; preds = %443
%451 = and i64 %447, 1152921504606846972
br label %452
452: ; preds = %452, %450
%453 = phi i64 [ 0, %450 ], [ %502, %452 ]
%454 = phi i64 [ 0, %450 ], [ %503, %452 ]
%455 = add nuw nsw i64 %453, %271
%456 = getelementptr inbounds i8, i8* %13, i64 %455
%457 = bitcast i8* %456 to <16 x i8>*
%458 = load <16 x i8>, <16 x i8>* %457
%459 = getelementptr inbounds i8, i8* %456, i64 16
%460 = bitcast i8* %459 to <16 x i8>*
%461 = load <16 x i8>, <16 x i8>* %460
%462 = getelementptr inbounds i8, i8* %428, i64 %453
%463 = bitcast i8* %462 to <16 x i8>*
store <16 x i8> %458, <16 x i8>* %463
%464 = getelementptr inbounds i8, i8* %462, i64 16
%465 = bitcast i8* %464 to <16 x i8>*
store <16 x i8> %461, <16 x i8>* %465
%466 = or i64 %453, 32
%467 = add nuw nsw i64 %466, %271
%468 = getelementptr inbounds i8, i8* %13, i64 %467
%469 = bitcast i8* %468 to <16 x i8>*
%470 = load <16 x i8>, <16 x i8>* %469
%471 = getelementptr inbounds i8, i8* %468, i64 16
%472 = bitcast i8* %471 to <16 x i8>*
%473 = load <16 x i8>, <16 x i8>* %472
%474 = getelementptr inbounds i8, i8* %428, i64 %466
%475 = bitcast i8* %474 to <16 x i8>*
store <16 x i8> %470, <16 x i8>* %475
%476 = getelementptr inbounds i8, i8* %474, i64 16
%477 = bitcast i8* %476 to <16 x i8>*
store <16 x i8> %473, <16 x i8>* %477
%478 = or i64 %453, 64
%479 = add nuw nsw i64 %478, %271
%480 = getelementptr inbounds i8, i8* %13, i64 %479
%481 = bitcast i8* %480 to <16 x i8>*
%482 = load <16 x i8>, <16 x i8>* %481
%483 = getelementptr inbounds i8, i8* %480, i64 16
%484 = bitcast i8* %483 to <16 x i8>*
%485 = load <16 x i8>, <16 x i8>* %484
%486 = getelementptr inbounds i8, i8* %428, i64 %478
%487 = bitcast i8* %486 to <16 x i8>*
store <16 x i8> %482, <16 x i8>* %487
%488 = getelementptr inbounds i8, i8* %486, i64 16
%489 = bitcast i8* %488 to <16 x i8>*
store <16 x i8> %485, <16 x i8>* %489
%490 = or i64 %453, 96
%491 = add nuw nsw i64 %490, %271
%492 = getelementptr inbounds i8, i8* %13, i64 %491
%493 = bitcast i8* %492 to <16 x i8>*
%494 = load <16 x i8>, <16 x i8>* %493
%495 = getelementptr inbounds i8, i8* %492, i64 16
%496 = bitcast i8* %495 to <16 x i8>*
%497 = load <16 x i8>, <16 x i8>* %496
%498 = getelementptr inbounds i8, i8* %428, i64 %490
%499 = bitcast i8* %498 to <16 x i8>*
store <16 x i8> %494, <16 x i8>* %499
%500 = getelementptr inbounds i8, i8* %498, i64 16
%501 = bitcast i8* %500 to <16 x i8>*
store <16 x i8> %497, <16 x i8>* %501
%502 = add nuw i64 %453, 128
%503 = add i64 %454, 4
%504 = icmp eq i64 %503, %451
br i1 %504, label %505, label %452
505: ; preds = %452, %443
%506 = phi i64 [ 0, %443 ], [ %502, %452 ]
%507 = icmp eq i64 %448, 0
br i1 %507, label %525, label %508
508: ; preds = %505, %508
%509 = phi i64 [ %522, %508 ], [ %506, %505 ]
%510 = phi i64 [ %523, %508 ], [ 0, %505 ]
%511 = add nuw nsw i64 %509, %271
%512 = getelementptr inbounds i8, i8* %13, i64 %511
%513 = bitcast i8* %512 to <16 x i8>*
%514 = load <16 x i8>, <16 x i8>* %513
%515 = getelementptr inbounds i8, i8* %512, i64 16
%516 = bitcast i8* %515 to <16 x i8>*
%517 = load <16 x i8>, <16 x i8>* %516
%518 = getelementptr inbounds i8, i8* %428, i64 %509
%519 = bitcast i8* %518 to <16 x i8>*
store <16 x i8> %514, <16 x i8>* %519
%520 = getelementptr inbounds i8, i8* %518, i64 16
%521 = bitcast i8* %520 to <16 x i8>*
store <16 x i8> %517, <16 x i8>* %521
%522 = add nuw i64 %509, 32
%523 = add i64 %510, 1
%524 = icmp eq i64 %523, %448
br i1 %524, label %525, label %508
525: ; preds = %508, %505
%526 = icmp eq i64 %444, %431
br i1 %526, label %590, label %527
527: ; preds = %525
%528 = and i64 %431, 24
%529 = icmp eq i64 %528, 0
br i1 %529, label %548, label %530
530: ; preds = %441, %527
%531 = phi i64 [ %444, %527 ], [ 0, %441 ]
%532 = trunc i64 %250 to i32
%533 = sub i32 %532, %246
%534 = zext i32 %533 to i64
%535 = and i64 %534, 4294967288
br label %536
536: ; preds = %536, %530
%537 = phi i64 [ %531, %530 ], [ %544, %536 ]
%538 = add nuw nsw i64 %537, %271
%539 = getelementptr inbounds i8, i8* %13, i64 %538
%540 = bitcast i8* %539 to <8 x i8>*
%541 = load <8 x i8>, <8 x i8>* %540
%542 = getelementptr inbounds i8, i8* %428, i64 %537
%543 = bitcast i8* %542 to <8 x i8>*
store <8 x i8> %541, <8 x i8>* %543
%544 = add nuw i64 %537, 8
%545 = icmp eq i64 %544, %535
br i1 %545, label %546, label %536
546: ; preds = %536
%547 = icmp eq i64 %535, %534
br i1 %547, label %590, label %548
548: ; preds = %433, %430, %527, %546
%549 = phi i64 [ 0, %430 ], [ 0, %433 ], [ %444, %527 ], [ %535, %546 ]
%550 = xor i64 %549, -1
%551 = add nsw i64 %550, %431
%552 = and i64 %431, 3
%553 = icmp eq i64 %552, 0
br i1 %553, label %564, label %554
554: ; preds = %548, %554
%555 = phi i64 [ %561, %554 ], [ %549, %548 ]
%556 = phi i64 [ %562, %554 ], [ 0, %548 ]
%557 = add nuw nsw i64 %555, %271
%558 = getelementptr inbounds i8, i8* %13, i64 %557
%559 = load i8, i8* %558
%560 = getelementptr inbounds i8, i8* %428, i64 %555
store i8 %559, i8* %560
%561 = add nuw nsw i64 %555, 1
%562 = add i64 %556, 1
%563 = icmp eq i64 %562, %552
br i1 %563, label %564, label %554
564: ; preds = %554, %548
%565 = phi i64 [ %549, %548 ], [ %561, %554 ]
%566 = icmp ult i64 %551, 3
br i1 %566, label %590, label %567
567: ; preds = %564, %567
%568 = phi i64 [ %588, %567 ], [ %565, %564 ]
%569 = add nuw nsw i64 %568, %271
%570 = getelementptr inbounds i8, i8* %13, i64 %569
%571 = load i8, i8* %570
%572 = getelementptr inbounds i8, i8* %428, i64 %568
store i8 %571, i8* %572
%573 = add nuw nsw i64 %568, 1
%574 = add nuw nsw i64 %573, %271
%575 = getelementptr inbounds i8, i8* %13, i64 %574
%576 = load i8, i8* %575
%577 = getelementptr inbounds i8, i8* %428, i64 %573
store i8 %576, i8* %577
%578 = add nuw nsw i64 %568, 2
%579 = add nuw nsw i64 %578, %271
%580 = getelementptr inbounds i8, i8* %13, i64 %579
%581 = load i8, i8* %580
%582 = getelementptr inbounds i8, i8* %428, i64 %578
store i8 %581, i8* %582
%583 = add nuw nsw i64 %568, 3
%584 = add nuw nsw i64 %583, %271
%585 = getelementptr inbounds i8, i8* %13, i64 %584
%586 = load i8, i8* %585
%587 = getelementptr inbounds i8, i8* %428, i64 %583
store i8 %586, i8* %587
%588 = add nuw nsw i64 %568, 4
%589 = icmp eq i64 %588, %431
br i1 %589, label %590, label %567
590: ; preds = %564, %567, %525, %546, %425
%591 = sext i32 %426 to i64
%592 = getelementptr inbounds i8, i8* %428, i64 %591
store i8 0, i8* %592
%593 = tail call i8* @strstr(i8* %18, i8* dereferenceable(1) %428)
%594 = ptrtoint i8* %593 to i64
%595 = tail call i32 @free(i8* %428)
%596 = icmp eq i8* %593, null
br i1 %596, label %305, label %597
597: ; preds = %590
br i1 %243, label %598, label %737
598: ; preds = %597, %598
%599 = phi i64 [ %602, %598 ], [ 0, %597 ]
%600 = getelementptr inbounds i8, i8* %17, i64 %599
%601 = icmp ult i8* %600, %593
%602 = add nuw i64 %599, 1
br i1 %601, label %598, label %603
603: ; preds = %598
%604 = trunc i64 %599 to i32
%605 = add nuw nsw i32 %604, 1
%606 = tail call i8* @malloc(i32 %605)
%607 = icmp ult i8* %17, %593
br i1 %607, label %608, label %729
608: ; preds = %603
%609 = sub i64 %594, %19
%610 = icmp ult i64 %609, 8
br i1 %610, label %718, label %611
611: ; preds = %608
%612 = getelementptr i8, i8* %606, i64 %609
%613 = getelementptr i8, i8* %17, i64 %609
%614 = icmp ult i8* %606, %613
%615 = icmp ult i8* %17, %612
%616 = and i1 %614, %615
br i1 %616, label %718, label %617
617: ; preds = %611
%618 = icmp ult i64 %609, 32
br i1 %618, label %702, label %619
619: ; preds = %617
%620 = and i64 %609, -32
%621 = add i64 %620, -32
%622 = lshr exact i64 %621, 5
%623 = add nuw nsw i64 %622, 1
%624 = and i64 %623, 3
%625 = icmp ult i64 %621, 96
br i1 %625, label %677, label %626
626: ; preds = %619
%627 = and i64 %623, 1152921504606846972
br label %628
628: ; preds = %628, %626
%629 = phi i64 [ 0, %626 ], [ %674, %628 ]
%630 = phi i64 [ 0, %626 ], [ %675, %628 ]
%631 = getelementptr i8, i8* %17, i64 %629
%632 = bitcast i8* %631 to <16 x i8>*
%633 = load <16 x i8>, <16 x i8>* %632
%634 = getelementptr i8, i8* %631, i64 16
%635 = bitcast i8* %634 to <16 x i8>*
%636 = load <16 x i8>, <16 x i8>* %635
%637 = getelementptr inbounds i8, i8* %606, i64 %629
%638 = bitcast i8* %637 to <16 x i8>*
store <16 x i8> %633, <16 x i8>* %638
%639 = getelementptr inbounds i8, i8* %637, i64 16
%640 = bitcast i8* %639 to <16 x i8>*
store <16 x i8> %636, <16 x i8>* %640
%641 = or i64 %629, 32
%642 = getelementptr i8, i8* %17, i64 %641
%643 = bitcast i8* %642 to <16 x i8>*
%644 = load <16 x i8>, <16 x i8>* %643
%645 = getelementptr i8, i8* %642, i64 16
%646 = bitcast i8* %645 to <16 x i8>*
%647 = load <16 x i8>, <16 x i8>* %646
%648 = getelementptr inbounds i8, i8* %606, i64 %641
%649 = bitcast i8* %648 to <16 x i8>*
store <16 x i8> %644, <16 x i8>* %649
%650 = getelementptr inbounds i8, i8* %648, i64 16
%651 = bitcast i8* %650 to <16 x i8>*
store <16 x i8> %647, <16 x i8>* %651
%652 = or i64 %629, 64
%653 = getelementptr i8, i8* %17, i64 %652
%654 = bitcast i8* %653 to <16 x i8>*
%655 = load <16 x i8>, <16 x i8>* %654
%656 = getelementptr i8, i8* %653, i64 16
%657 = bitcast i8* %656 to <16 x i8>*
%658 = load <16 x i8>, <16 x i8>* %657
%659 = getelementptr inbounds i8, i8* %606, i64 %652
%660 = bitcast i8* %659 to <16 x i8>*
store <16 x i8> %655, <16 x i8>* %660
%661 = getelementptr inbounds i8, i8* %659, i64 16
%662 = bitcast i8* %661 to <16 x i8>*
store <16 x i8> %658, <16 x i8>* %662
%663 = or i64 %629, 96
%664 = getelementptr i8, i8* %17, i64 %663
%665 = bitcast i8* %664 to <16 x i8>*
%666 = load <16 x i8>, <16 x i8>* %665
%667 = getelementptr i8, i8* %664, i64 16
%668 = bitcast i8* %667 to <16 x i8>*
%669 = load <16 x i8>, <16 x i8>* %668
%670 = getelementptr inbounds i8, i8* %606, i64 %663
%671 = bitcast i8* %670 to <16 x i8>*
store <16 x i8> %666, <16 x i8>* %671
%672 = getelementptr inbounds i8, i8* %670, i64 16
%673 = bitcast i8* %672 to <16 x i8>*
store <16 x i8> %669, <16 x i8>* %673
%674 = add nuw i64 %629, 128
%675 = add i64 %630, 4
%676 = icmp eq i64 %675, %627
br i1 %676, label %677, label %628
677: ; preds = %628, %619
%678 = phi i64 [ 0, %619 ], [ %674, %628 ]
%679 = icmp eq i64 %624, 0
br i1 %679, label %696, label %680
680: ; preds = %677, %680
%681 = phi i64 [ %693, %680 ], [ %678, %677 ]
%682 = phi i64 [ %694, %680 ], [ 0, %677 ]
%683 = getelementptr i8, i8* %17, i64 %681
%684 = bitcast i8* %683 to <16 x i8>*
%685 = load <16 x i8>, <16 x i8>* %684
%686 = getelementptr i8, i8* %683, i64 16
%687 = bitcast i8* %686 to <16 x i8>*
%688 = load <16 x i8>, <16 x i8>* %687
%689 = getelementptr inbounds i8, i8* %606, i64 %681
%690 = bitcast i8* %689 to <16 x i8>*
store <16 x i8> %685, <16 x i8>* %690
%691 = getelementptr inbounds i8, i8* %689, i64 16
%692 = bitcast i8* %691 to <16 x i8>*
store <16 x i8> %688, <16 x i8>* %692
%693 = add nuw i64 %681, 32
%694 = add i64 %682, 1
%695 = icmp eq i64 %694, %624
br i1 %695, label %696, label %680
696: ; preds = %680, %677
%697 = icmp eq i64 %609, %620
br i1 %697, label %729, label %698
698: ; preds = %696
%699 = getelementptr i8, i8* %17, i64 %620
%700 = and i64 %609, 24
%701 = icmp eq i64 %700, 0
br i1 %701, label %718, label %702
702: ; preds = %617, %698
%703 = phi i64 [ %620, %698 ], [ 0, %617 ]
%704 = sub i64 %594, %19
%705 = and i64 %704, -8
%706 = getelementptr i8, i8* %17, i64 %705
br label %707
707: ; preds = %707, %702
%708 = phi i64 [ %703, %702 ], [ %714, %707 ]
%709 = getelementptr i8, i8* %17, i64 %708
%710 = bitcast i8* %709 to <8 x i8>*
%711 = load <8 x i8>, <8 x i8>* %710
%712 = getelementptr inbounds i8, i8* %606, i64 %708
%713 = bitcast i8* %712 to <8 x i8>*
store <8 x i8> %711, <8 x i8>* %713
%714 = add nuw i64 %708, 8
%715 = icmp eq i64 %714, %705
br i1 %715, label %716, label %707
716: ; preds = %707
%717 = icmp eq i64 %704, %705
br i1 %717, label %729, label %718
718: ; preds = %611, %608, %698, %716
%719 = phi i64 [ 0, %608 ], [ 0, %611 ], [ %620, %698 ], [ %705, %716 ]
%720 = phi i8* [ %17, %608 ], [ %17, %611 ], [ %699, %698 ], [ %706, %716 ]
br label %721
721: ; preds = %718, %721
%722 = phi i64 [ %726, %721 ], [ %719, %718 ]
%723 = phi i8* [ %727, %721 ], [ %720, %718 ]
%724 = load i8, i8* %723
%725 = getelementptr inbounds i8, i8* %606, i64 %722
store i8 %724, i8* %725
%726 = add nuw nsw i64 %722, 1
%727 = getelementptr inbounds i8, i8* %17, i64 %726
%728 = icmp eq i64 %726, %609
br i1 %728, label %729, label %721
729: ; preds = %721, %696, %716, %603
%730 = phi i64 [ 0, %603 ], [ %609, %716 ], [ %609, %696 ], [ %609, %721 ]
%731 = and i64 %730, 4294967295
%732 = getelementptr inbounds i8, i8* %606, i64 %731
store i8 0, i8* %732
%733 = tail call i32 @e_p_konv_mess(i8* %247, i8* %606, i8* %3, i8* %4, i8* %5, i32* %6, i32* %7)
%734 = tail call i32 @free(i8* %247)
%735 = tail call i32 @free(i8* %606)
%736 = icmp eq i32 %733, 0
br i1 %736, label %737, label %305
737: ; preds = %729, %597
%738 = load i8, i8* %268
%739 = icmp eq i8 %738, 0
br i1 %739, label %740, label %750
740: ; preds = %737
%741 = getelementptr inbounds i8, i8* %593, i64 %591
%742 = load i8, i8* %741
%743 = icmp eq i8 %742, 0
br i1 %743, label %305, label %744
744: ; preds = %740
%745 = getelementptr inbounds i8, i8* %593, i64 1
br label %746
746: ; preds = %744, %761
%747 = phi i8* [ %745, %744 ], [ %762, %761 ]
%748 = phi i8* [ %745, %744 ], [ %765, %761 ]
%749 = icmp ugt i8* %748, %747
br i1 %749, label %305, label %16
750: ; preds = %737
%751 = getelementptr inbounds i8, i8* %272, i64 %591
%752 = getelementptr inbounds i8, i8* %593, i64 %591
%753 = tail call i32 @e_p_comp_mess(i8* %751, i8* %752, i8* %752, i8* %3, i8* %4, i8* %5, i32* %6, i32* %7)
%754 = icmp eq i32 %753, 0
br i1 %754, label %755, label %305
755: ; preds = %750
%756 = load i8, i8* %4
%757 = icmp eq i8 %756, 0
br i1 %757, label %761, label %758
758: ; preds = %755
%759 = load i32, i32* %6
%760 = icmp sgt i32 %759, -1
br i1 %760, label %305, label %761
761: ; preds = %758, %755
%762 = getelementptr inbounds i8, i8* %593, i64 1
%763 = load i8, i8* %13
%764 = icmp eq i8 %763, 36
%765 = select i1 %764, i8* %17, i8* %762
br label %746
766: ; preds = %267
%767 = trunc i64 %250 to i32
%768 = add nsw i32 %767, -1
%769 = getelementptr inbounds i8, i8* %18, i64 1
br label %856
770: ; preds = %267
%771 = trunc i64 %250 to i32
%772 = load i8, i8* %14
switch i8 %772, label %814 [
i8 33, label %773
i8 0, label %305
]
773: ; preds = %770
%774 = getelementptr inbounds i8, i8* %13, i64 2
%775 = load i8, i8* %774
%776 = icmp eq i8 %775, 0
br i1 %776, label %804, label %777
777: ; preds = %773, %800
%778 = phi i64 [ %786, %800 ], [ 2, %773 ]
%779 = phi i8 [ %788, %800 ], [ %775, %773 ]
%780 = icmp ne i8 %779, 93
%781 = icmp eq i64 %778, 2
%782 = select i1 %780, i1 true, i1 %781
br i1 %782, label %783, label %807
783: ; preds = %777
%784 = icmp eq i8 %779, %244
br i1 %784, label %802, label %785
785: ; preds = %783
%786 = add nuw i64 %778, 1
%787 = getelementptr inbounds i8, i8* %13, i64 %786
%788 = load i8, i8* %787
%789 = icmp ne i8 %788, 45
%790 = icmp slt i8 %244, %779
%791 = select i1 %789, i1 true, i1 %790
br i1 %791, label %800, label %792
792: ; preds = %785
%793 = add nuw nsw i64 %778, 2
%794 = getelementptr inbounds i8, i8* %13, i64 %793
%795 = load i8, i8* %794
%796 = icmp sgt i8 %244, %795
br i1 %796, label %800, label %797
797: ; preds = %792
%798 = sext i8 %244 to i32
%799 = sub nsw i32 0, %798
br label %305
800: ; preds = %785, %792
%801 = icmp eq i8 %788, 0
br i1 %801, label %804, label %777
802: ; preds = %783
%803 = icmp eq i8 %244, 93
br i1 %803, label %807, label %804
804: ; preds = %802, %773, %800
%805 = sext i8 %244 to i32
%806 = sub nsw i32 0, %805
br label %305
807: ; preds = %777, %802
%808 = trunc i64 %778 to i32
%809 = add nuw nsw i32 %808, 1
%810 = sub nsw i32 %771, %809
%811 = zext i32 %809 to i64
%812 = getelementptr inbounds i8, i8* %13, i64 %811
%813 = getelementptr inbounds i8, i8* %18, i64 1
br label %856
814: ; preds = %770, %834
%815 = phi i64 [ %823, %834 ], [ 1, %770 ]
%816 = phi i8 [ %825, %834 ], [ %772, %770 ]
%817 = icmp ne i8 %816, 93
%818 = icmp eq i64 %815, 1
%819 = select i1 %817, i1 true, i1 %818
br i1 %819, label %820, label %305
820: ; preds = %814
%821 = icmp eq i8 %816, %244
br i1 %821, label %836, label %822
822: ; preds = %820
%823 = add nuw i64 %815, 1
%824 = getelementptr inbounds i8, i8* %13, i64 %823
%825 = load i8, i8* %824
%826 = icmp ne i8 %825, 45
%827 = icmp slt i8 %244, %816
%828 = select i1 %826, i1 true, i1 %827
br i1 %828, label %834, label %829
829: ; preds = %822
%830 = add nuw nsw i64 %815, 2
%831 = getelementptr inbounds i8, i8* %13, i64 %830
%832 = load i8, i8* %831
%833 = icmp sgt i8 %244, %832
br i1 %833, label %834, label %836
834: ; preds = %822, %829
%835 = icmp eq i8 %825, 0
br i1 %835, label %305, label %814
836: ; preds = %829, %820
%837 = phi i8 [ %816, %829 ], [ %244, %820 ]
%838 = icmp eq i8 %837, 93
br i1 %838, label %305, label %839
839: ; preds = %836
%840 = and i64 %815, 4294967295
br label %841
841: ; preds = %839, %845
%842 = phi i64 [ %840, %839 ], [ %846, %845 ]
%843 = getelementptr inbounds i8, i8* %13, i64 %842
%844 = load i8, i8* %843
switch i8 %844, label %845 [
i8 0, label %847
i8 93, label %847
]
845: ; preds = %841
%846 = add nuw i64 %842, 1
br label %841
847: ; preds = %841, %841
%848 = trunc i64 %842 to i32
%849 = add nuw nsw i32 %848, 1
%850 = sub nsw i32 %771, %849
%851 = zext i32 %849 to i64
%852 = getelementptr inbounds i8, i8* %13, i64 %851
%853 = getelementptr inbounds i8, i8* %18, i64 1
br label %856
854: ; preds = %267
%855 = trunc i64 %250 to i32
br label %856
856: ; preds = %854, %766, %807, %847
%857 = phi i8* [ %769, %766 ], [ %813, %807 ], [ %853, %847 ], [ %18, %854 ]
%858 = phi i8* [ %14, %766 ], [ %812, %807 ], [ %852, %847 ], [ %13, %854 ]
%859 = phi i32 [ %768, %766 ], [ %810, %807 ], [ %850, %847 ], [ %855, %854 ]
%860 = icmp slt i32 %859, 1
br i1 %860, label %35, label %861
861: ; preds = %856
%862 = tail call i32 @strncmp(i8* %858, i8* %857, i32 %859)
%863 = icmp eq i32 %862, 0
br i1 %863, label %864, label %305
864: ; preds = %861
%865 = zext i32 %859 to i64
%866 = getelementptr inbounds i8, i8* %858, i64 %865
%867 = getelementptr inbounds i8, i8* %857, i64 %865
%868 = getelementptr inbounds i8, i8* %17, i64 %865
br label %35
}