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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int atoi(char *);
scalar_t__ regmatchInsensitive(char *, char *);
int /*<<< orphan*/ slog(int, char *, char *);
int /*<<< orphan*/ strcmp(char *, char *);
int strlen(char *);
char *strstr(char *, char *);
int /*<<< orphan*/ trim(char *);
int split_audit_objective(char *string, char *event, char *user, char *match,
                          int *excludeflag, int *excludematchflag,
                          int *returncode) {
  char *startevent, *startuser, *startmatch, *startcrit, *startreturn;
  char *stringpointer, *endstring;
  char *eventp, *userp, *matchp, *critp;
  char criticality[8192];
  int crit = 0;
  *returncode = 999;
  if (string == (char *)NULL || event == (char *)NULL || user == (char *)NULL ||
      match == (char *)NULL) {
    return (-1);
  }
  if (!strlen(string)) {
    return (-1);
  }
  startcrit = strstr(string, "criticality=");
  startevent = strstr(string, "event=");
  startreturn = strstr(string, "return=");
  startuser = strstr(string, "user=");
  if (startuser == (char *)NULL) {
    startuser = strstr(string, "user!=");
    if (startuser != (char *)NULL) {
      *excludeflag = 1;
    } else {
      *excludeflag = -1;
    }
  }
  startmatch = strstr(string, "match=");
  if (startmatch == (char *)NULL) {
    startmatch = strstr(string, "match!=");
    if (startmatch != (char *)NULL) {
      *excludematchflag = 1;
    } else {
      *excludematchflag = -1;
    }
  }
  stringpointer = string;
  eventp = event;
  userp = user;
  matchp = match;
  critp = criticality;
  endstring = &string[strlen(string)];
  if (startevent == (char *)NULL || startcrit == (char *)NULL) {
    slog(1, "The following line does not contain the criticality, event: [%s]",
         string);
    return (-1);
  }
  stringpointer = startcrit + strlen("criticality=");
  while (*stringpointer &&
         (stringpointer != startcrit && stringpointer != startreturn &&
          stringpointer != startuser && stringpointer != startmatch &&
          stringpointer != endstring)) {
    *critp = *stringpointer;
    critp++;
    stringpointer++;
  }
  *critp = '\0';
  trim(criticality);
  crit = atoi(criticality);
  if (crit < 0)
    crit = 0;
  if (crit > 4)
    crit = 4;
  stringpointer = startevent + strlen("event=");
  while (*stringpointer &&
         (stringpointer != startcrit && stringpointer != startreturn &&
          stringpointer != startuser && stringpointer != startmatch &&
          stringpointer != endstring)) {
    *eventp = *stringpointer;
    eventp++;
    stringpointer++;
  }
  *eventp = '\0';
  trim(event);
  if (startreturn != (char *)NULL) {
    stringpointer = startreturn + strlen("return=");
    if (regmatchInsensitive(stringpointer, "^[(]?success[)]?")) {
      *returncode = 1;
    } else if (regmatchInsensitive(stringpointer, "^[(]?failure[)]?")) {
      *returncode = 0;
    } else {
      *returncode = 999;
    }
  } else {
    *returncode = 999;
  }
  if (startuser != (char *)NULL) {
    if (*excludeflag) {
      stringpointer = startuser + strlen("user!=");
    } else {
      stringpointer = startuser + strlen("user=");
    }
    while (*stringpointer &&
           (stringpointer != startcrit && stringpointer != startreturn &&
            stringpointer != startmatch && stringpointer != startevent &&
            stringpointer != endstring)) {
      *userp = *stringpointer;
      stringpointer++;
      userp++;
    }
    *userp = '\0';
    trim(user);
    if (((strlen(user) == 1) && (!strcmp(user, "*"))) ||
        ((strlen(user) == 3) && (!strcmp(user, "(*)")))) {
      user[0] = '\0';
    }
  }
  if (startmatch != (char *)NULL) {
    if (*excludematchflag) {
      stringpointer = startmatch + strlen("match!=");
    } else {
      stringpointer = startmatch + strlen("match=");
    }
    while (*stringpointer &&
           (stringpointer != startcrit && stringpointer != startreturn &&
            stringpointer != startevent && stringpointer != startuser &&
            stringpointer != endstring)) {
      *matchp = *stringpointer;
      stringpointer++;
      matchp++;
    }
    *matchp = '\0';
    trim(match);
    if (((strlen(match) == 1) && (!strcmp(match, "*"))) ||
        ((strlen(match) == 3) && (!strcmp(match, "(*)")))) {
      match[0] = '\0';
    }
  }
  return (crit);
}


x86 assembly (clang, -O0):
<split_audit_objective>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2100,%rsp
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,-0x2094(%rbp)
mov    0x10(%rbp),%rax
movl   $0x3e7,(%rax)
cmpq   $0x0,-0x10(%rbp)
je     11d7 <split_audit_objective+0x67>
cmpq   $0x0,-0x18(%rbp)
je     11d7 <split_audit_objective+0x67>
cmpq   $0x0,-0x20(%rbp)
je     11d7 <split_audit_objective+0x67>
cmpq   $0x0,-0x28(%rbp)
jne    11e3 <split_audit_objective+0x73>
movl   $0xffffffff,-0x4(%rbp)
jmp    19f5 <split_audit_objective+0x885>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x0,%eax
jne    1201 <split_audit_objective+0x91>
movl   $0xffffffff,-0x4(%rbp)
jmp    19f5 <split_audit_objective+0x885>
mov    -0x10(%rbp),%rdi
lea    0xdf4(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xded(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xde0(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xdd4(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    1299 <split_audit_objective+0x129>
mov    -0x10(%rbp),%rdi
lea    0xdbb(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
je     128a <split_audit_objective+0x11a>
mov    -0x30(%rbp),%rax
movl   $0x1,(%rax)
jmp    1294 <split_audit_objective+0x124>
mov    -0x30(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1299 <split_audit_objective+0x129>
mov    -0x10(%rbp),%rdi
lea    0xd85(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jne    12f5 <split_audit_objective+0x185>
mov    -0x10(%rbp),%rdi
lea    0xd6d(%rip),%rsi
call   1090 <strstr@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
je     12e6 <split_audit_objective+0x176>
mov    -0x38(%rbp),%rax
movl   $0x1,(%rax)
jmp    12f0 <split_audit_objective+0x180>
mov    -0x38(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    12f5 <split_audit_objective+0x185>
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x88(%rbp)
lea    -0x2090(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20a0(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x20a0(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1363 <split_audit_objective+0x1f3>
cmpq   $0x0,-0x58(%rbp)
jne    1384 <split_audit_objective+0x214>
mov    -0x10(%rbp),%rdx
mov    $0x1,%edi
lea    0xcc5(%rip),%rsi
call   1060 <slog@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    19f5 <split_audit_objective+0x885>
mov    -0x58(%rbp),%rax
mov    %rax,-0x20a8(%rbp)
lea    0xc6a(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x20a8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x20a9(%rbp)
je     143b <split_audit_objective+0x2cb>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x58(%rbp),%rcx
mov    %al,-0x20aa(%rbp)
je     142f <split_audit_objective+0x2bf>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp),%rcx
mov    %al,-0x20aa(%rbp)
je     142f <split_audit_objective+0x2bf>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x48(%rbp),%rcx
mov    %al,-0x20aa(%rbp)
je     142f <split_audit_objective+0x2bf>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x50(%rbp),%rcx
mov    %al,-0x20aa(%rbp)
je     142f <split_audit_objective+0x2bf>
mov    -0x68(%rbp),%rax
cmp    -0x70(%rbp),%rax
setne  %al
mov    %al,-0x20aa(%rbp)
mov    -0x20aa(%rbp),%al
mov    %al,-0x20a9(%rbp)
mov    -0x20a9(%rbp),%al
test   $0x1,%al
jne    144e <split_audit_objective+0x2de>
jmp    1480 <split_audit_objective+0x310>
mov    -0x68(%rbp),%rax
mov    (%rax),%cl
mov    -0x90(%rbp),%rax
mov    %cl,(%rax)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    13ae <split_audit_objective+0x23e>
mov    -0x90(%rbp),%rax
movb   $0x0,(%rax)
lea    -0x2090(%rbp),%rdi
call   1040 <trim@plt>
lea    -0x2090(%rbp),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x2094(%rbp)
cmpl   $0x0,-0x2094(%rbp)
jge    14bf <split_audit_objective+0x34f>
movl   $0x0,-0x2094(%rbp)
cmpl   $0x4,-0x2094(%rbp)
jle    14d6 <split_audit_objective+0x366>
movl   $0x4,-0x2094(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x20b8(%rbp)
lea    0xb25(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x20b8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x20b9(%rbp)
je     158d <split_audit_objective+0x41d>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x58(%rbp),%rcx
mov    %al,-0x20ba(%rbp)
je     1581 <split_audit_objective+0x411>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp),%rcx
mov    %al,-0x20ba(%rbp)
je     1581 <split_audit_objective+0x411>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x48(%rbp),%rcx
mov    %al,-0x20ba(%rbp)
je     1581 <split_audit_objective+0x411>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x50(%rbp),%rcx
mov    %al,-0x20ba(%rbp)
je     1581 <split_audit_objective+0x411>
mov    -0x68(%rbp),%rax
cmp    -0x70(%rbp),%rax
setne  %al
mov    %al,-0x20ba(%rbp)
mov    -0x20ba(%rbp),%al
mov    %al,-0x20b9(%rbp)
mov    -0x20b9(%rbp),%al
test   $0x1,%al
jne    15a0 <split_audit_objective+0x430>
jmp    15c9 <split_audit_objective+0x459>
mov    -0x68(%rbp),%rax
mov    (%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,(%rax)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1500 <split_audit_objective+0x390>
mov    -0x78(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x18(%rbp),%rdi
call   1040 <trim@plt>
cmpq   $0x0,-0x60(%rbp)
je     1674 <split_audit_objective+0x504>
mov    -0x60(%rbp),%rax
mov    %rax,-0x20c8(%rbp)
lea    0xa1e(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x20c8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rdi
lea    0xa60(%rip),%rsi
call   1080 <regmatchInsensitive@plt>
cmp    $0x0,%rax
je     1637 <split_audit_objective+0x4c7>
mov    0x10(%rbp),%rax
movl   $0x1,(%rax)
jmp    166f <split_audit_objective+0x4ff>
mov    -0x68(%rbp),%rdi
lea    0xa48(%rip),%rsi
call   1080 <regmatchInsensitive@plt>
cmp    $0x0,%rax
je     1660 <split_audit_objective+0x4f0>
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
jmp    166a <split_audit_objective+0x4fa>
mov    0x10(%rbp),%rax
movl   $0x3e7,(%rax)
jmp    166f <split_audit_objective+0x4ff>
jmp    167e <split_audit_objective+0x50e>
mov    0x10(%rbp),%rax
movl   $0x3e7,(%rax)
cmpq   $0x0,-0x48(%rbp)
je     182f <split_audit_objective+0x6bf>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     16c5 <split_audit_objective+0x555>
mov    -0x48(%rbp),%rax
mov    %rax,-0x20d0(%rbp)
lea    0x97a(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x20d0(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
jmp    16ef <split_audit_objective+0x57f>
mov    -0x48(%rbp),%rax
mov    %rax,-0x20d8(%rbp)
lea    0x945(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x20d8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
jmp    16f4 <split_audit_objective+0x584>
mov    -0x68(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x20d9(%rbp)
je     1781 <split_audit_objective+0x611>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x58(%rbp),%rcx
mov    %al,-0x20da(%rbp)
je     1775 <split_audit_objective+0x605>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp),%rcx
mov    %al,-0x20da(%rbp)
je     1775 <split_audit_objective+0x605>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x50(%rbp),%rcx
mov    %al,-0x20da(%rbp)
je     1775 <split_audit_objective+0x605>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x40(%rbp),%rcx
mov    %al,-0x20da(%rbp)
je     1775 <split_audit_objective+0x605>
mov    -0x68(%rbp),%rax
cmp    -0x70(%rbp),%rax
setne  %al
mov    %al,-0x20da(%rbp)
mov    -0x20da(%rbp),%al
mov    %al,-0x20d9(%rbp)
mov    -0x20d9(%rbp),%al
test   $0x1,%al
jne    1794 <split_audit_objective+0x624>
jmp    17bd <split_audit_objective+0x64d>
mov    -0x68(%rbp),%rax
mov    (%rax),%cl
mov    -0x80(%rbp),%rax
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    16f4 <split_audit_objective+0x584>
mov    -0x80(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rdi
call   1040 <trim@plt>
mov    -0x20(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x1,%eax
jne    17f8 <split_audit_objective+0x688>
mov    -0x20(%rbp),%rdi
lea    0x8b1(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%eax
je     1823 <split_audit_objective+0x6b3>
mov    -0x20(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x3,%eax
jne    182a <split_audit_objective+0x6ba>
mov    -0x20(%rbp),%rdi
lea    0x888(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%eax
jne    182a <split_audit_objective+0x6ba>
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
jmp    182f <split_audit_objective+0x6bf>
cmpq   $0x0,-0x50(%rbp)
je     19ec <split_audit_objective+0x87c>
mov    -0x38(%rbp),%rax
cmpl   $0x0,(%rax)
je     1876 <split_audit_objective+0x706>
mov    -0x50(%rbp),%rax
mov    %rax,-0x20e8(%rbp)
lea    0x7d7(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x20e8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
jmp    18a0 <split_audit_objective+0x730>
mov    -0x50(%rbp),%rax
mov    %rax,-0x20f0(%rbp)
lea    0x7a1(%rip),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x20f0(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
jmp    18a5 <split_audit_objective+0x735>
mov    -0x68(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x20f1(%rbp)
je     1932 <split_audit_objective+0x7c2>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x58(%rbp),%rcx
mov    %al,-0x20f2(%rbp)
je     1926 <split_audit_objective+0x7b6>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp),%rcx
mov    %al,-0x20f2(%rbp)
je     1926 <split_audit_objective+0x7b6>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x40(%rbp),%rcx
mov    %al,-0x20f2(%rbp)
je     1926 <split_audit_objective+0x7b6>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x48(%rbp),%rcx
mov    %al,-0x20f2(%rbp)
je     1926 <split_audit_objective+0x7b6>
mov    -0x68(%rbp),%rax
cmp    -0x70(%rbp),%rax
setne  %al
mov    %al,-0x20f2(%rbp)
mov    -0x20f2(%rbp),%al
mov    %al,-0x20f1(%rbp)
mov    -0x20f1(%rbp),%al
test   $0x1,%al
jne    1945 <split_audit_objective+0x7d5>
jmp    1977 <split_audit_objective+0x807>
mov    -0x68(%rbp),%rax
mov    (%rax),%cl
mov    -0x88(%rbp),%rax
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    18a5 <split_audit_objective+0x735>
mov    -0x88(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x28(%rbp),%rdi
call   1040 <trim@plt>
mov    -0x28(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x1,%eax
jne    19b5 <split_audit_objective+0x845>
mov    -0x28(%rbp),%rdi
lea    0x6f4(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%eax
je     19e0 <split_audit_objective+0x870>
mov    -0x28(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x3,%eax
jne    19e7 <split_audit_objective+0x877>
mov    -0x28(%rbp),%rdi
lea    0x6cb(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%eax
jne    19e7 <split_audit_objective+0x877>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
jmp    19ec <split_audit_objective+0x87c>
mov    -0x2094(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<split_audit_objective>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2048,%rsp
mov    0x2080(%rsp),%rax
movl   $0x3e7,(%rax)
mov    $0xffffffff,%ebp
test   %rdi,%rdi
je     1687 <split_audit_objective+0x517>
test   %rsi,%rsi
je     1687 <split_audit_objective+0x517>
test   %rdx,%rdx
je     1687 <split_audit_objective+0x517>
mov    %rcx,%r12
test   %rcx,%rcx
je     1687 <split_audit_objective+0x517>
mov    %r9,%rbx
mov    %r8,%r15
mov    %rdi,%r14
mov    %rsi,0x8(%rsp)
mov    %rdx,0x38(%rsp)
call   1030 <strlen@plt>
test   %eax,%eax
je     1687 <split_audit_objective+0x517>
mov    %rbx,0x20(%rsp)
lea    0xe19(%rip),%rsi
mov    %r14,%rdi
call   1090 <strstr@plt>
mov    %rax,%rbp
lea    0xe14(%rip),%rsi
mov    %r14,%rdi
call   1090 <strstr@plt>
mov    %rax,0x18(%rsp)
lea    0xe07(%rip),%rsi
mov    %r14,%rdi
call   1090 <strstr@plt>
mov    %rax,%r13
lea    0xdfd(%rip),%rsi
mov    %r14,%rdi
call   1090 <strstr@plt>
mov    %rax,%rbx
test   %rax,%rax
jne    124d <split_audit_objective+0xdd>
lea    0xdec(%rip),%rsi
mov    %r14,%rdi
call   1090 <strstr@plt>
mov    %rax,%rbx
cmp    $0x1,%rax
sbb    %eax,%eax
or     $0x1,%eax
mov    %eax,(%r15)
mov    %r15,0x30(%rsp)
lea    0xdd0(%rip),%rsi
mov    %r14,%rdi
call   1090 <strstr@plt>
mov    %rax,%r15
test   %rax,%rax
jne    128b <split_audit_objective+0x11b>
lea    0xdc0(%rip),%rsi
mov    %r14,%rdi
call   1090 <strstr@plt>
mov    %rax,%r15
cmp    $0x1,%rax
sbb    %eax,%eax
or     $0x1,%eax
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
mov    %r14,%rdi
call   1030 <strlen@plt>
cmpq   $0x0,0x18(%rsp)
je     1443 <split_audit_objective+0x2d3>
test   %rbp,%rbp
je     1443 <split_audit_objective+0x2d3>
mov    %r12,0x28(%rsp)
cltq
add    %rax,%r14
lea    0x40(%rsp),%r12
lea    0xd42(%rip),%rdi
call   1030 <strlen@plt>
movslq %eax,%rcx
mov    0x0(%rbp,%rcx,1),%dl
test   %dl,%dl
je     1332 <split_audit_objective+0x1c2>
test   %eax,%eax
je     1332 <split_audit_objective+0x1c2>
lea    (%rcx,%rbp,1),%rax
cmp    %r13,%rax
je     1332 <split_audit_objective+0x1c2>
cmp    %rbx,%rax
je     1332 <split_audit_objective+0x1c2>
cmp    %r15,%rax
je     1332 <split_audit_objective+0x1c2>
cmp    %r14,%rax
je     1332 <split_audit_objective+0x1c2>
lea    0x40(%rsp),%r12
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %dl,(%r12)
add    $0x1,%r12
movzbl 0x0(%rbp,%rcx,1),%edx
test   %dl,%dl
je     1332 <split_audit_objective+0x1c2>
test   %rcx,%rcx
je     1332 <split_audit_objective+0x1c2>
lea    (%rcx,%rbp,1),%rax
cmp    %r13,%rax
je     1332 <split_audit_objective+0x1c2>
cmp    %rbx,%rax
je     1332 <split_audit_objective+0x1c2>
cmp    %r15,%rax
je     1332 <split_audit_objective+0x1c2>
add    $0x1,%rcx
cmp    %r14,%rax
jne    1300 <split_audit_objective+0x190>
movb   $0x0,(%r12)
lea    0x40(%rsp),%r12
mov    %r12,%rdi
call   1040 <trim@plt>
mov    %r12,%rdi
call   1070 <atoi@plt>
xor    %ecx,%ecx
test   %eax,%eax
cmovns %eax,%ecx
cmp    $0x4,%ecx
mov    $0x4,%eax
cmovb  %ecx,%eax
mov    %eax,0x14(%rsp)
lea    0xca4(%rip),%rdi
call   1030 <strlen@plt>
movslq %eax,%r8
mov    0x18(%rsp),%rdx
mov    (%rdx,%r8,1),%cl
mov    0x8(%rsp),%rdi
mov    %rdi,%rax
test   %cl,%cl
je     13ed <split_audit_objective+0x27d>
lea    (%rdx,%r8,1),%rsi
mov    %rdi,%rax
cmp    %rbp,%rsi
je     13ed <split_audit_objective+0x27d>
mov    %rdi,%rax
cmp    %r13,%rsi
je     13ed <split_audit_objective+0x27d>
mov    %rdi,%rax
cmp    %rbx,%rsi
je     13ed <split_audit_objective+0x27d>
mov    %rdi,%rax
cmp    %r15,%rsi
je     13ed <split_audit_objective+0x27d>
mov    %rdi,%rax
cmp    %r14,%rsi
je     13ed <split_audit_objective+0x27d>
add    %r8,%rdx
add    $0x1,%rdx
mov    %rdi,%rax
nopl   0x0(%rax)
mov    %cl,(%rax)
add    $0x1,%rax
movzbl (%rdx),%ecx
test   %cl,%cl
je     13ed <split_audit_objective+0x27d>
cmp    %rbp,%rdx
je     13ed <split_audit_objective+0x27d>
cmp    %r13,%rdx
je     13ed <split_audit_objective+0x27d>
cmp    %rbx,%rdx
je     13ed <split_audit_objective+0x27d>
cmp    %r15,%rdx
je     13ed <split_audit_objective+0x27d>
lea    0x1(%rdx),%rsi
cmp    %r14,%rdx
mov    %rsi,%rdx
jne    13c0 <split_audit_objective+0x250>
movb   $0x0,(%rax)
call   1040 <trim@plt>
test   %r13,%r13
je     1461 <split_audit_objective+0x2f1>
lea    0xc13(%rip),%rdi
call   1030 <strlen@plt>
movslq %eax,%r12
add    %r13,%r12
lea    0xc66(%rip),%rsi
mov    %r12,%rdi
call   1080 <regmatchInsensitive@plt>
mov    $0x1,%ecx
test   %rax,%rax
jne    1466 <split_audit_objective+0x2f6>
lea    0xc5e(%rip),%rsi
mov    %r12,%rdi
call   1080 <regmatchInsensitive@plt>
xor    %edx,%edx
test   %rax,%rax
mov    $0x3e7,%ecx
cmovne %edx,%ecx
jmp    1466 <split_audit_objective+0x2f6>
lea    0xbee(%rip),%rsi
mov    $0x1,%edi
mov    %r14,%rdx
call   1060 <slog@plt>
mov    $0xffffffff,%ebp
jmp    1687 <split_audit_objective+0x517>
mov    $0x3e7,%ecx
mov    0x2080(%rsp),%rax
mov    %ecx,(%rax)
test   %rbx,%rbx
mov    0x38(%rsp),%r12
je     1582 <split_audit_objective+0x412>
mov    0x30(%rsp),%rax
cmpl   $0x0,(%rax)
lea    0xb95(%rip),%rdi
lea    0xb88(%rip),%rax
cmove  %rax,%rdi
call   1030 <strlen@plt>
movslq %eax,%rdx
mov    %rbx,%rax
mov    %rbx,0x8(%rsp)
mov    (%rbx,%rdx,1),%cl
mov    %r12,%rax
test   %cl,%cl
mov    0x18(%rsp),%rbx
je     152d <split_audit_objective+0x3bd>
mov    0x8(%rsp),%rax
lea    (%rax,%rdx,1),%rsi
mov    %r12,%rax
cmp    %rbp,%rsi
je     152d <split_audit_objective+0x3bd>
mov    %r12,%rax
cmp    %r13,%rsi
je     152d <split_audit_objective+0x3bd>
mov    %r12,%rax
cmp    %r15,%rsi
je     152d <split_audit_objective+0x3bd>
mov    %r12,%rax
cmp    %rbx,%rsi
je     152d <split_audit_objective+0x3bd>
mov    %r12,%rax
cmp    %r14,%rsi
je     152d <split_audit_objective+0x3bd>
mov    0x8(%rsp),%rax
add    %rax,%rdx
add    $0x1,%rdx
mov    %r12,%rax
nopw   0x0(%rax,%rax,1)
mov    %cl,(%rax)
add    $0x1,%rax
movzbl (%rdx),%ecx
test   %cl,%cl
je     152d <split_audit_objective+0x3bd>
cmp    %rbp,%rdx
je     152d <split_audit_objective+0x3bd>
cmp    %r13,%rdx
je     152d <split_audit_objective+0x3bd>
cmp    %r15,%rdx
je     152d <split_audit_objective+0x3bd>
cmp    %rbx,%rdx
je     152d <split_audit_objective+0x3bd>
lea    0x1(%rdx),%rsi
cmp    %r14,%rdx
mov    %rsi,%rdx
jne    1500 <split_audit_objective+0x390>
movb   $0x0,(%rax)
mov    %r12,%rdi
call   1040 <trim@plt>
mov    %r12,%rdi
call   1030 <strlen@plt>
cmp    $0x1,%eax
mov    0x8(%rsp),%rbx
jne    155d <split_audit_objective+0x3ed>
lea    0xb4a(%rip),%rsi
mov    %r12,%rdi
call   1050 <strcmp@plt>
test   %eax,%eax
je     157d <split_audit_objective+0x40d>
mov    %r12,%rdi
call   1030 <strlen@plt>
cmp    $0x3,%eax
jne    1582 <split_audit_objective+0x412>
lea    0xb2c(%rip),%rsi
mov    %r12,%rdi
call   1050 <strcmp@plt>
test   %eax,%eax
jne    1582 <split_audit_objective+0x412>
movb   $0x0,(%r12)
test   %r15,%r15
je     1683 <split_audit_objective+0x513>
mov    0x20(%rsp),%rax
cmpl   $0x0,(%rax)
lea    0xa96(%rip),%rdi
lea    0xa88(%rip),%rax
cmove  %rax,%rdi
call   1030 <strlen@plt>
movslq %eax,%rdx
mov    (%r15,%rdx,1),%cl
mov    0x28(%rsp),%r12
mov    %r12,%rax
test   %cl,%cl
mov    0x18(%rsp),%rdi
je     162d <split_audit_objective+0x4bd>
lea    (%r15,%rdx,1),%rsi
mov    %r12,%rax
cmp    %rbp,%rsi
je     162d <split_audit_objective+0x4bd>
mov    %r12,%rax
cmp    %r13,%rsi
je     162d <split_audit_objective+0x4bd>
mov    %r12,%rax
cmp    %rdi,%rsi
je     162d <split_audit_objective+0x4bd>
mov    %r12,%rax
cmp    %rbx,%rsi
je     162d <split_audit_objective+0x4bd>
mov    %r12,%rax
cmp    %r14,%rsi
je     162d <split_audit_objective+0x4bd>
add    %r15,%rdx
add    $0x1,%rdx
mov    %r12,%rax
nopl   0x0(%rax,%rax,1)
mov    %cl,(%rax)
add    $0x1,%rax
movzbl (%rdx),%ecx
test   %cl,%cl
je     162d <split_audit_objective+0x4bd>
cmp    %rbp,%rdx
je     162d <split_audit_objective+0x4bd>
cmp    %r13,%rdx
je     162d <split_audit_objective+0x4bd>
cmp    %rdi,%rdx
je     162d <split_audit_objective+0x4bd>
cmp    %rbx,%rdx
je     162d <split_audit_objective+0x4bd>
lea    0x1(%rdx),%rsi
cmp    %r14,%rdx
mov    %rsi,%rdx
jne    1600 <split_audit_objective+0x490>
movb   $0x0,(%rax)
mov    %r12,%rdi
call   1040 <trim@plt>
mov    %r12,%rdi
call   1030 <strlen@plt>
cmp    $0x1,%eax
mov    0x14(%rsp),%ebp
jne    165c <split_audit_objective+0x4ec>
lea    0xa4b(%rip),%rsi
mov    %r12,%rdi
call   1050 <strcmp@plt>
test   %eax,%eax
je     167c <split_audit_objective+0x50c>
mov    %r12,%rdi
call   1030 <strlen@plt>
cmp    $0x3,%eax
jne    1687 <split_audit_objective+0x517>
lea    0xa2d(%rip),%rsi
mov    %r12,%rdi
call   1050 <strcmp@plt>
test   %eax,%eax
jne    1687 <split_audit_objective+0x517>
movb   $0x0,(%r12)
jmp    1687 <split_audit_objective+0x517>
mov    0x14(%rsp),%ebp
mov    %ebp,%eax
add    $0x2048,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [13 x i8] c"criticality=\00"
@.str.1 = [7 x i8] c"event=\00"
@.str.2 = [8 x i8] c"return=\00"
@.str.3 = [6 x i8] c"user=\00"
@.str.4 = [7 x i8] c"user!=\00"
@.str.5 = [7 x i8] c"match=\00"
@.str.6 = [8 x i8] c"match!=\00"
@.str.7 = [65 x i8] c"The following line does not contain the criticality, event: [%s]\00"
@.str.8 = [17 x i8] c"^[(]?success[)]?\00"
@.str.9 = [17 x i8] c"^[(]?failure[)]?\00"
@.str.10 = [2 x i8] c"*\00"
@.str.11 = [4 x i8] c"(*)\00"
define i32 @split_audit_objective(i8* %0, i8* %1, i8* %2, i8* %3, i32* nocapture %4, i32* nocapture %5, i32* nocapture writeonly %6) {
%8 = alloca [8192 x i8]
%9 = getelementptr inbounds [8192 x i8], [8192 x i8]* %8, i64 0, i64 0
store i32 999, i32* %6
%10 = icmp eq i8* %0, null
%11 = icmp eq i8* %1, null
%12 = or i1 %10, %11
%13 = icmp eq i8* %2, null
%14 = or i1 %12, %13
%15 = icmp eq i8* %3, null
%16 = or i1 %14, %15
br i1 %16, label %246, label %17
17: ; preds = %7
%18 = tail call i32 @strlen(i8* %0)
%19 = icmp eq i32 %18, 0
br i1 %19, label %246, label %20
20: ; preds = %17
%21 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0))
%22 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%23 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%24 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
%25 = icmp eq i8* %24, null
br i1 %25, label %26, label %30
26: ; preds = %20
%27 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0))
%28 = icmp eq i8* %27, null
%29 = select i1 %28, i32 -1, i32 1
store i32 %29, i32* %4
br label %30
30: ; preds = %26, %20
%31 = phi i8* [ %24, %20 ], [ %27, %26 ]
%32 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%33 = icmp eq i8* %32, null
br i1 %33, label %34, label %38
34: ; preds = %30
%35 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0))
%36 = icmp eq i8* %35, null
%37 = select i1 %36, i32 -1, i32 1
store i32 %37, i32* %5
br label %38
38: ; preds = %34, %30
%39 = phi i8* [ %32, %30 ], [ %35, %34 ]
%40 = tail call i32 @strlen(i8* %0)
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %0, i64 %41
%43 = icmp eq i8* %22, null
%44 = icmp eq i8* %21, null
%45 = select i1 %43, i1 true, i1 %44
br i1 %45, label %46, label %48
46: ; preds = %38
%47 = tail call i32 @slog(i32 1, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.7, i64 0, i64 0), i8* %0)
br label %246
48: ; preds = %38
%49 = tail call i32 @strlen(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0))
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %21, i64 %50
%52 = load i8, i8* %51
%53 = icmp eq i8 %52, 0
%54 = icmp eq i32 %49, 0
%55 = select i1 %53, i1 true, i1 %54
%56 = icmp eq i8* %51, %23
%57 = select i1 %55, i1 true, i1 %56
%58 = icmp eq i8* %51, %31
%59 = select i1 %57, i1 true, i1 %58
%60 = icmp eq i8* %51, %39
%61 = select i1 %59, i1 true, i1 %60
%62 = icmp eq i8* %51, %42
%63 = select i1 %61, i1 true, i1 %62
br i1 %63, label %82, label %64
64: ; preds = %48, %64
%65 = phi i8 [ %70, %64 ], [ %52, %48 ]
%66 = phi i8* [ %68, %64 ], [ %9, %48 ]
%67 = phi i8* [ %69, %64 ], [ %51, %48 ]
store i8 %65, i8* %66
%68 = getelementptr inbounds i8, i8* %66, i64 1
%69 = getelementptr inbounds i8, i8* %67, i64 1
%70 = load i8, i8* %69
%71 = icmp eq i8 %70, 0
%72 = icmp eq i8* %69, %21
%73 = select i1 %71, i1 true, i1 %72
%74 = icmp eq i8* %69, %23
%75 = select i1 %73, i1 true, i1 %74
%76 = icmp eq i8* %69, %31
%77 = select i1 %75, i1 true, i1 %76
%78 = icmp eq i8* %69, %39
%79 = select i1 %77, i1 true, i1 %78
%80 = icmp eq i8* %69, %42
%81 = select i1 %79, i1 true, i1 %80
br i1 %81, label %82, label %64
82: ; preds = %64, %48
%83 = phi i8* [ %9, %48 ], [ %68, %64 ]
store i8 0, i8* %83
%84 = call i32 @trim(i8* %9)
%85 = call i32 @atoi(i8* %9)
%86 = icmp sgt i32 %85, 0
%87 = select i1 %86, i32 %85, i32 0
%88 = icmp ult i32 %87, 4
%89 = select i1 %88, i32 %87, i32 4
%90 = call i32 @strlen(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %22, i64 %91
%93 = load i8, i8* %92
%94 = icmp eq i8 %93, 0
%95 = icmp eq i8* %92, %21
%96 = select i1 %94, i1 true, i1 %95
%97 = icmp eq i8* %92, %23
%98 = select i1 %96, i1 true, i1 %97
%99 = icmp eq i8* %92, %31
%100 = select i1 %98, i1 true, i1 %99
%101 = icmp eq i8* %92, %39
%102 = select i1 %100, i1 true, i1 %101
%103 = icmp eq i8* %92, %42
%104 = select i1 %102, i1 true, i1 %103
br i1 %104, label %123, label %105
105: ; preds = %82, %105
%106 = phi i8 [ %111, %105 ], [ %93, %82 ]
%107 = phi i8* [ %109, %105 ], [ %1, %82 ]
%108 = phi i8* [ %110, %105 ], [ %92, %82 ]
store i8 %106, i8* %107
%109 = getelementptr inbounds i8, i8* %107, i64 1
%110 = getelementptr inbounds i8, i8* %108, i64 1
%111 = load i8, i8* %110
%112 = icmp eq i8 %111, 0
%113 = icmp eq i8* %110, %21
%114 = select i1 %112, i1 true, i1 %113
%115 = icmp eq i8* %110, %23
%116 = select i1 %114, i1 true, i1 %115
%117 = icmp eq i8* %110, %31
%118 = select i1 %116, i1 true, i1 %117
%119 = icmp eq i8* %110, %39
%120 = select i1 %118, i1 true, i1 %119
%121 = icmp eq i8* %110, %42
%122 = select i1 %120, i1 true, i1 %121
br i1 %122, label %123, label %105
123: ; preds = %105, %82
%124 = phi i8* [ %1, %82 ], [ %109, %105 ]
store i8 0, i8* %124
%125 = call i32 @trim(i8* %1)
%126 = icmp eq i8* %23, null
br i1 %126, label %137, label %127
127: ; preds = %123
%128 = call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %23, i64 %129
%131 = call i64 @regmatchInsensitive(i8* %130, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0))
%132 = icmp eq i64 %131, 0
br i1 %132, label %133, label %137
133: ; preds = %127
%134 = call i64 @regmatchInsensitive(i8* %130, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.9, i64 0, i64 0))
%135 = icmp eq i64 %134, 0
%136 = select i1 %135, i32 999, i32 0
br label %137
137: ; preds = %123, %133, %127
%138 = phi i32 [ 1, %127 ], [ %136, %133 ], [ 999, %123 ]
store i32 %138, i32* %6
%139 = icmp eq i8* %31, null
br i1 %139, label %192, label %140
140: ; preds = %137
%141 = load i32, i32* %4
%142 = icmp eq i32 %141, 0
%143 = select i1 %142, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0)
%144 = call i32 @strlen(i8* %143)
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i8, i8* %31, i64 %145
%147 = load i8, i8* %146
%148 = icmp eq i8 %147, 0
%149 = icmp eq i8* %146, %21
%150 = select i1 %148, i1 true, i1 %149
%151 = icmp eq i8* %146, %23
%152 = select i1 %150, i1 true, i1 %151
%153 = icmp eq i8* %146, %39
%154 = select i1 %152, i1 true, i1 %153
%155 = icmp eq i8* %146, %22
%156 = select i1 %154, i1 true, i1 %155
%157 = icmp eq i8* %146, %42
%158 = select i1 %156, i1 true, i1 %157
br i1 %158, label %177, label %159
159: ; preds = %140, %159
%160 = phi i8 [ %165, %159 ], [ %147, %140 ]
%161 = phi i8* [ %164, %159 ], [ %2, %140 ]
%162 = phi i8* [ %163, %159 ], [ %146, %140 ]
store i8 %160, i8* %161
%163 = getelementptr inbounds i8, i8* %162, i64 1
%164 = getelementptr inbounds i8, i8* %161, i64 1
%165 = load i8, i8* %163
%166 = icmp eq i8 %165, 0
%167 = icmp eq i8* %163, %21
%168 = select i1 %166, i1 true, i1 %167
%169 = icmp eq i8* %163, %23
%170 = select i1 %168, i1 true, i1 %169
%171 = icmp eq i8* %163, %39
%172 = select i1 %170, i1 true, i1 %171
%173 = icmp eq i8* %163, %22
%174 = select i1 %172, i1 true, i1 %173
%175 = icmp eq i8* %163, %42
%176 = select i1 %174, i1 true, i1 %175
br i1 %176, label %177, label %159
177: ; preds = %159, %140
%178 = phi i8* [ %2, %140 ], [ %164, %159 ]
store i8 0, i8* %178
%179 = call i32 @trim(i8* %2)
%180 = call i32 @strlen(i8* %2)
%181 = icmp eq i32 %180, 1
br i1 %181, label %182, label %185
182: ; preds = %177
%183 = call i32 @strcmp(i8* dereferenceable(1) %2, i8* dereferenceable(2) getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
%184 = icmp eq i32 %183, 0
br i1 %184, label %191, label %185
185: ; preds = %182, %177
%186 = call i32 @strlen(i8* %2)
%187 = icmp eq i32 %186, 3
br i1 %187, label %188, label %192
188: ; preds = %185
%189 = call i32 @strcmp(i8* dereferenceable(1) %2, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0))
%190 = icmp eq i32 %189, 0
br i1 %190, label %191, label %192
191: ; preds = %188, %182
store i8 0, i8* %2
br label %192
192: ; preds = %185, %188, %191, %137
%193 = icmp eq i8* %39, null
br i1 %193, label %246, label %194
194: ; preds = %192
%195 = load i32, i32* %5
%196 = icmp eq i32 %195, 0
%197 = select i1 %196, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0)
%198 = call i32 @strlen(i8* %197)
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %39, i64 %199
%201 = load i8, i8* %200
%202 = icmp eq i8 %201, 0
%203 = icmp eq i8* %200, %21
%204 = select i1 %202, i1 true, i1 %203
%205 = icmp eq i8* %200, %23
%206 = select i1 %204, i1 true, i1 %205
%207 = icmp eq i8* %200, %22
%208 = select i1 %206, i1 true, i1 %207
%209 = icmp eq i8* %200, %31
%210 = select i1 %208, i1 true, i1 %209
%211 = icmp eq i8* %200, %42
%212 = select i1 %210, i1 true, i1 %211
br i1 %212, label %231, label %213
213: ; preds = %194, %213
%214 = phi i8 [ %219, %213 ], [ %201, %194 ]
%215 = phi i8* [ %218, %213 ], [ %3, %194 ]
%216 = phi i8* [ %217, %213 ], [ %200, %194 ]
store i8 %214, i8* %215
%217 = getelementptr inbounds i8, i8* %216, i64 1
%218 = getelementptr inbounds i8, i8* %215, i64 1
%219 = load i8, i8* %217
%220 = icmp eq i8 %219, 0
%221 = icmp eq i8* %217, %21
%222 = select i1 %220, i1 true, i1 %221
%223 = icmp eq i8* %217, %23
%224 = select i1 %222, i1 true, i1 %223
%225 = icmp eq i8* %217, %22
%226 = select i1 %224, i1 true, i1 %225
%227 = icmp eq i8* %217, %31
%228 = select i1 %226, i1 true, i1 %227
%229 = icmp eq i8* %217, %42
%230 = select i1 %228, i1 true, i1 %229
br i1 %230, label %231, label %213
231: ; preds = %213, %194
%232 = phi i8* [ %3, %194 ], [ %218, %213 ]
store i8 0, i8* %232
%233 = call i32 @trim(i8* %3)
%234 = call i32 @strlen(i8* %3)
%235 = icmp eq i32 %234, 1
br i1 %235, label %236, label %239
236: ; preds = %231
%237 = call i32 @strcmp(i8* dereferenceable(1) %3, i8* dereferenceable(2) getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
%238 = icmp eq i32 %237, 0
br i1 %238, label %245, label %239
239: ; preds = %236, %231
%240 = call i32 @strlen(i8* %3)
%241 = icmp eq i32 %240, 3
br i1 %241, label %242, label %246
242: ; preds = %239
%243 = call i32 @strcmp(i8* dereferenceable(1) %3, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0))
%244 = icmp eq i32 %243, 0
br i1 %244, label %245, label %246
245: ; preds = %242, %236
store i8 0, i8* %3
br label %246
246: ; preds = %192, %245, %242, %239, %17, %7, %46
%247 = phi i32 [ -1, %46 ], [ -1, %7 ], [ -1, %17 ], [ %89, %239 ], [ %89, %242 ], [ %89, %245 ], [ %89, %192 ]
ret i32 %247
}