#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 */
struct inotify_event {
  int mask;
  scalar_t__ len;
  char *name;
  int /*<<< orphan*/ wd;
};

/* Variables and functions */
int IN_ACCESS;
int IN_ATTRIB;
int IN_CLOSE_NOWRITE;
int IN_CLOSE_WRITE;
int IN_CREATE;
int IN_DELETE;
int IN_DELETE_SELF;
int IN_IGNORED;
int IN_ISDIR;
int IN_MODIFY;
int IN_MOVED_FROM;
int IN_MOVED_TO;
int IN_MOVE_SELF;
int IN_OPEN;
int IN_Q_OVERFLOW;
int IN_UNMOUNT;
int PATH_MAX;
int /*<<< orphan*/ addWatch(char *);
char *pathPrefix(int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, char *, ...);
int /*<<< orphan*/ rmWatch(int /*<<< orphan*/);
int /*<<< orphan*/ snprintf(char *, int, char *, char *, char *);
void logEvent(struct inotify_event *event) {
  if (event->mask & IN_ACCESS) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was accessed");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was accessed");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was accessed");
    }
  };
  if (event->mask & IN_ATTRIB) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "had its metadata changed");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "had its metadata changed");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd),
             "had its metadata changed");
    }
  };
  if (event->mask & IN_CLOSE_NOWRITE) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was closed (read-only)");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was closed (read-only)");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd),
             "was closed (read-only)");
    }
  };
  if (event->mask & IN_CLOSE_WRITE) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was closed");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was closed");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was closed");
    }
  };
  if (event->mask & IN_CREATE) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was created");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was created");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was created");
    }
  };
  if (event->mask & IN_DELETE) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was deleted");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was deleted");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was deleted");
    }
  };
  if (event->mask & IN_DELETE_SELF) {
    printf("[%s] ", "WARNING");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was deleted (watched directory)");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was deleted (watched directory)");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd),
             "was deleted (watched directory)");
    }
  };
  if (event->mask & IN_IGNORED) {
    printf("[%s] ", "WARNING");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "is no longer being watched (maybe it was deleted?)");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "is no longer being watched (maybe it was deleted?)");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd),
             "is no longer being watched (maybe it was deleted?)");
    }
  };
  if (event->mask & IN_MODIFY) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was modified");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was modified");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was modified");
    }
  };
  if (event->mask & IN_MOVE_SELF) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was moved");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was moved");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was moved");
    }
  };
  if (event->mask & IN_MOVED_FROM) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was moved");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was moved");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was moved");
    }
  };
  if (event->mask & IN_MOVED_TO) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was moved");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was moved");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was moved");
    }
  };
  if (event->mask & IN_OPEN) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was opened");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was opened");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was opened");
    }
  };
  if (event->mask & IN_Q_OVERFLOW) {
    printf("[%s] ", "FATAL");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "too many queued file events");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "too many queued file events");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd),
             "too many queued file events");
    }
  };
  if (event->mask & IN_UNMOUNT) {
    printf("[%s] ", "INFO");
    if (event->len > 0) {
      if (event->mask & IN_ISDIR) {
        printf("Directory %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was unmounted");
      } else {
        printf("File %s/%s %s\n", pathPrefix(event->wd), event->name,
               "was unmounted");
      }
    } else {
      printf("Directory %s %s\n", pathPrefix(event->wd), "was unmounted");
    }
  };
  if (event->mask & IN_IGNORED) {
    rmWatch(event->wd);
  }
  if (event->mask & IN_ISDIR && event->mask & IN_CREATE) {
    char path[PATH_MAX];
    snprintf(path, PATH_MAX, "%s/%s", pathPrefix(event->wd), event->name);
    addWatch(path);
  }
}


x86 assembly (clang, -O0):
<logEvent>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2e2f(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     123b <logEvent+0xeb>
lea    0xe85(%rip),%rdi
lea    0xe84(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    1212 <logEvent+0xc2>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2e03(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     11e1 <logEvent+0x91>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xe3d(%rip),%rdi
lea    0xe4a(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    120d <logEvent+0xbd>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xe2d(%rip),%rdi
lea    0xe19(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1236 <logEvent+0xe6>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0xe13(%rip),%rdi
lea    0xdf0(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    123b <logEvent+0xeb>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2d88(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     131a <logEvent+0x1ca>
lea    0xda6(%rip),%rdi
lea    0xda5(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    12f1 <logEvent+0x1a1>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2d24(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     12c0 <logEvent+0x170>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xd5e(%rip),%rdi
lea    0xd98(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    12ec <logEvent+0x19c>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xd4e(%rip),%rdi
lea    0xd67(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1315 <logEvent+0x1c5>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0xd34(%rip),%rdi
lea    0xd3e(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    131a <logEvent+0x1ca>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2ca1(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     13f9 <logEvent+0x2a9>
lea    0xcc7(%rip),%rdi
lea    0xcc6(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    13d0 <logEvent+0x280>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2c45(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     139f <logEvent+0x24f>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xc7f(%rip),%rdi
lea    0xcd2(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13cb <logEvent+0x27b>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xc6f(%rip),%rdi
lea    0xca1(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13f4 <logEvent+0x2a4>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0xc55(%rip),%rdi
lea    0xc78(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13f9 <logEvent+0x2a9>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2bba(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     14d8 <logEvent+0x388>
lea    0xbe8(%rip),%rdi
lea    0xbe7(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    14af <logEvent+0x35f>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2b66(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     147e <logEvent+0x32e>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xba0(%rip),%rdi
lea    0xc0a(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    14aa <logEvent+0x35a>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xb90(%rip),%rdi
lea    0xbd9(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    14d3 <logEvent+0x383>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0xb76(%rip),%rdi
lea    0xbb0(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    14d8 <logEvent+0x388>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2a8b(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     15b7 <logEvent+0x467>
lea    0xb09(%rip),%rdi
lea    0xb08(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    158e <logEvent+0x43e>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2a87(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     155d <logEvent+0x40d>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xac1(%rip),%rdi
lea    0xb36(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1589 <logEvent+0x439>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0xab1(%rip),%rdi
lea    0xb05(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    15b2 <logEvent+0x462>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0xa97(%rip),%rdi
lea    0xadc(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    15b7 <logEvent+0x467>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x29f4(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1696 <logEvent+0x546>
lea    0xa2a(%rip),%rdi
lea    0xa29(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    166d <logEvent+0x51d>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x29a8(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     163c <logEvent+0x4ec>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x9e2(%rip),%rdi
lea    0xa63(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1668 <logEvent+0x518>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x9d2(%rip),%rdi
lea    0xa32(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1691 <logEvent+0x541>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x9b8(%rip),%rdi
lea    0xa09(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1696 <logEvent+0x546>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x28b5(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1775 <logEvent+0x625>
lea    0x94b(%rip),%rdi
lea    0x9e3(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    174c <logEvent+0x5fc>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x28c9(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     171b <logEvent+0x5cb>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x903(%rip),%rdi
lea    0x998(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1747 <logEvent+0x5f7>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x8f3(%rip),%rdi
lea    0x967(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1770 <logEvent+0x620>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x8d9(%rip),%rdi
lea    0x93e(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1775 <logEvent+0x625>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2876(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1854 <logEvent+0x704>
lea    0x86c(%rip),%rdi
lea    0x904(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    182b <logEvent+0x6db>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x27ea(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     17fa <logEvent+0x6aa>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x824(%rip),%rdi
lea    0x8d9(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1826 <logEvent+0x6d6>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x814(%rip),%rdi
lea    0x8a8(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    184f <logEvent+0x6ff>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x7fa(%rip),%rdi
lea    0x87f(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1854 <logEvent+0x704>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x277f(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1933 <logEvent+0x7e3>
lea    0x78d(%rip),%rdi
lea    0x78c(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    190a <logEvent+0x7ba>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x270b(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     18d9 <logEvent+0x789>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x745(%rip),%rdi
lea    0x82d(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1905 <logEvent+0x7b5>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x735(%rip),%rdi
lea    0x7fc(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    192e <logEvent+0x7de>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x71b(%rip),%rdi
lea    0x7d3(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1933 <logEvent+0x7e3>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2638(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1a12 <logEvent+0x8c2>
lea    0x6ae(%rip),%rdi
lea    0x6ad(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    19e9 <logEvent+0x899>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x262c(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     19b8 <logEvent+0x868>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x666(%rip),%rdi
lea    0x75b(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    19e4 <logEvent+0x894>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x656(%rip),%rdi
lea    0x72a(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1a0d <logEvent+0x8bd>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x63c(%rip),%rdi
lea    0x701(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1a12 <logEvent+0x8c2>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2561(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1af1 <logEvent+0x9a1>
lea    0x5cf(%rip),%rdi
lea    0x5ce(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    1ac8 <logEvent+0x978>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x254d(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1a97 <logEvent+0x947>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x587(%rip),%rdi
lea    0x67c(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1ac3 <logEvent+0x973>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x577(%rip),%rdi
lea    0x64b(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1aec <logEvent+0x99c>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x55d(%rip),%rdi
lea    0x622(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1af1 <logEvent+0x9a1>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2492(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1bd0 <logEvent+0xa80>
lea    0x4f0(%rip),%rdi
lea    0x4ef(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    1ba7 <logEvent+0xa57>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x246e(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1b76 <logEvent+0xa26>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x4a8(%rip),%rdi
lea    0x59d(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1ba2 <logEvent+0xa52>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x498(%rip),%rdi
lea    0x56c(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1bcb <logEvent+0xa7b>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x47e(%rip),%rdi
lea    0x543(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1bd0 <logEvent+0xa80>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2383(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1caf <logEvent+0xb5f>
lea    0x411(%rip),%rdi
lea    0x410(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    1c86 <logEvent+0xb36>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x238f(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1c55 <logEvent+0xb05>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x3c9(%rip),%rdi
lea    0x4c8(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1c81 <logEvent+0xb31>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x3b9(%rip),%rdi
lea    0x497(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1caa <logEvent+0xb5a>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x39f(%rip),%rdi
lea    0x46e(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1caf <logEvent+0xb5f>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x22cc(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1d8e <logEvent+0xc3e>
lea    0x332(%rip),%rdi
lea    0x447(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    1d65 <logEvent+0xc15>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x22b0(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1d34 <logEvent+0xbe4>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x2ea(%rip),%rdi
lea    0x3fa(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1d60 <logEvent+0xc10>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x2da(%rip),%rdi
lea    0x3c9(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1d89 <logEvent+0xc39>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x2c0(%rip),%rdi
lea    0x3a0(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1d8e <logEvent+0xc3e>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x2215(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1e6d <logEvent+0xd1d>
lea    0x253(%rip),%rdi
lea    0x252(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jle    1e44 <logEvent+0xcf4>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x21d1(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1e13 <logEvent+0xcc3>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x20b(%rip),%rdi
lea    0x337(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1e3f <logEvent+0xcef>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdx
lea    0x1fb(%rip),%rdi
lea    0x306(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1e68 <logEvent+0xd18>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    %rax,%rsi
lea    0x1e1(%rip),%rdi
lea    0x2dd(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1e6d <logEvent+0xd1d>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x217e(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1e91 <logEvent+0xd41>
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1060 <rmWatch@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x210a(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1f33 <logEvent+0xde3>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    0x20ba(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1f33 <logEvent+0xde3>
mov    0x2120(%rip),%rax
mov    (%rax),%eax
mov    %rsp,%rcx
mov    %rcx,-0x10(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x20(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x18(%rbp)
mov    0x20f4(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <pathPrefix@plt>
mov    -0x24(%rbp),%esi
mov    -0x20(%rbp),%rdi
mov    %rax,%rcx
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%r8
lea    0x22e(%rip),%rdx
call   1050 <snprintf@plt>
mov    -0x20(%rbp),%rdi
call   1070 <addWatch@plt>
mov    -0x10(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<logEvent>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rdi,%r14
mov    0x2e33(%rip),%rax
mov    (%rax),%eax
test   %eax,(%rdi)
je     11e8 <logEvent+0x98>
lea    0xe8e(%rip),%rdi
lea    0xe8d(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    11ad <logEvent+0x5d>
mov    0x2e1a(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     11d0 <logEvent+0x80>
lea    0xe60(%rip),%rdi
jmp    11d7 <logEvent+0x87>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xe7e(%rip),%rdi
lea    0xe5b(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    11e8 <logEvent+0x98>
lea    0xe55(%rip),%rdi
lea    0xe41(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2de1(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     1273 <logEvent+0x123>
lea    0xe03(%rip),%rdi
lea    0xe02(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    1238 <logEvent+0xe8>
mov    0x2d8f(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     125b <logEvent+0x10b>
lea    0xdd5(%rip),%rdi
jmp    1262 <logEvent+0x112>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xdf3(%rip),%rdi
lea    0xdfd(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1273 <logEvent+0x123>
lea    0xdca(%rip),%rdi
lea    0xde3(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2d4e(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     12fe <logEvent+0x1ae>
lea    0xd78(%rip),%rdi
lea    0xd77(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    12c3 <logEvent+0x173>
mov    0x2d04(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     12e6 <logEvent+0x196>
lea    0xd4a(%rip),%rdi
jmp    12ed <logEvent+0x19d>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xd68(%rip),%rdi
lea    0xd8b(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    12fe <logEvent+0x1ae>
lea    0xd3f(%rip),%rdi
lea    0xd71(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2cbb(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     1389 <logEvent+0x239>
lea    0xced(%rip),%rdi
lea    0xcec(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    134e <logEvent+0x1fe>
mov    0x2c79(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     1371 <logEvent+0x221>
lea    0xcbf(%rip),%rdi
jmp    1378 <logEvent+0x228>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xcdd(%rip),%rdi
lea    0xd17(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1389 <logEvent+0x239>
lea    0xcb4(%rip),%rdi
lea    0xcfd(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2be0(%rip),%r15
mov    (%r15),%eax
test   %eax,(%r14)
je     1415 <logEvent+0x2c5>
lea    0xc61(%rip),%rdi
lea    0xc60(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    13da <logEvent+0x28a>
mov    0x2bed(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     13fd <logEvent+0x2ad>
lea    0xc33(%rip),%rdi
jmp    1404 <logEvent+0x2b4>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xc51(%rip),%rdi
lea    0xc96(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1415 <logEvent+0x2c5>
lea    0xc28(%rip),%rdi
lea    0xc7c(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2b9c(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     14a0 <logEvent+0x350>
lea    0xbd6(%rip),%rdi
lea    0xbd5(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    1465 <logEvent+0x315>
mov    0x2b62(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     1488 <logEvent+0x338>
lea    0xba8(%rip),%rdi
jmp    148f <logEvent+0x33f>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xbc6(%rip),%rdi
lea    0xc17(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    14a0 <logEvent+0x350>
lea    0xb9d(%rip),%rdi
lea    0xbfd(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2ab1(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     152b <logEvent+0x3db>
lea    0xb4b(%rip),%rdi
lea    0xbe3(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    14f0 <logEvent+0x3a0>
mov    0x2ad7(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     1513 <logEvent+0x3c3>
lea    0xb1d(%rip),%rdi
jmp    151a <logEvent+0x3ca>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xb3b(%rip),%rdi
lea    0xba0(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    152b <logEvent+0x3db>
lea    0xb12(%rip),%rdi
lea    0xb86(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2ac6(%rip),%r12
mov    (%r12),%eax
test   %eax,(%r14)
je     15b8 <logEvent+0x468>
lea    0xabe(%rip),%rdi
lea    0xb56(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    157d <logEvent+0x42d>
mov    0x2a4a(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     15a0 <logEvent+0x450>
lea    0xa90(%rip),%rdi
jmp    15a7 <logEvent+0x457>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xaae(%rip),%rdi
lea    0xb33(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    15b8 <logEvent+0x468>
lea    0xa85(%rip),%rdi
lea    0xb19(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2a21(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     1643 <logEvent+0x4f3>
lea    0xa33(%rip),%rdi
lea    0xa32(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    1608 <logEvent+0x4b8>
mov    0x29bf(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     162b <logEvent+0x4db>
lea    0xa05(%rip),%rdi
jmp    1632 <logEvent+0x4e2>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0xa23(%rip),%rdi
lea    0xadb(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1643 <logEvent+0x4f3>
lea    0x9fa(%rip),%rdi
lea    0xac1(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x292e(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     16ce <logEvent+0x57e>
lea    0x9a8(%rip),%rdi
lea    0x9a7(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    1693 <logEvent+0x543>
mov    0x2934(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     16b6 <logEvent+0x566>
lea    0x97a(%rip),%rdi
jmp    16bd <logEvent+0x56d>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0x998(%rip),%rdi
lea    0xa5d(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    16ce <logEvent+0x57e>
lea    0x96f(%rip),%rdi
lea    0xa43(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28ab(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     1759 <logEvent+0x609>
lea    0x91d(%rip),%rdi
lea    0x91c(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    171e <logEvent+0x5ce>
mov    0x28a9(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     1741 <logEvent+0x5f1>
lea    0x8ef(%rip),%rdi
jmp    1748 <logEvent+0x5f8>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0x90d(%rip),%rdi
lea    0x9d2(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1759 <logEvent+0x609>
lea    0x8e4(%rip),%rdi
lea    0x9b8(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2830(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     17e4 <logEvent+0x694>
lea    0x892(%rip),%rdi
lea    0x891(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    17a9 <logEvent+0x659>
mov    0x281e(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     17cc <logEvent+0x67c>
lea    0x864(%rip),%rdi
jmp    17d3 <logEvent+0x683>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0x882(%rip),%rdi
lea    0x947(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    17e4 <logEvent+0x694>
lea    0x859(%rip),%rdi
lea    0x92d(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2775(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     186f <logEvent+0x71f>
lea    0x807(%rip),%rdi
lea    0x806(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    1834 <logEvent+0x6e4>
mov    0x2793(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     1857 <logEvent+0x707>
lea    0x7d9(%rip),%rdi
jmp    185e <logEvent+0x70e>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0x7f7(%rip),%rdi
lea    0x8c6(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    186f <logEvent+0x71f>
lea    0x7ce(%rip),%rdi
lea    0x8ac(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2712(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     18fa <logEvent+0x7aa>
lea    0x77c(%rip),%rdi
lea    0x891(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    18bf <logEvent+0x76f>
mov    0x2708(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     18e2 <logEvent+0x792>
lea    0x74e(%rip),%rdi
jmp    18e9 <logEvent+0x799>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0x76c(%rip),%rdi
lea    0x84c(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    18fa <logEvent+0x7aa>
lea    0x743(%rip),%rdi
lea    0x832(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x26af(%rip),%rax
mov    (%rax),%eax
test   %eax,(%r14)
je     1985 <logEvent+0x835>
lea    0x6f1(%rip),%rdi
lea    0x6f0(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,0x8(%r14)
jle    194a <logEvent+0x7fa>
mov    0x267d(%rip),%rax
mov    (%rax),%ebx
and    (%r14),%ebx
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%rdx
test   %ebx,%ebx
je     196d <logEvent+0x81d>
lea    0x6c3(%rip),%rdi
jmp    1974 <logEvent+0x824>
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
lea    0x6e1(%rip),%rdi
lea    0x7dd(%rip),%rdx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1985 <logEvent+0x835>
lea    0x6b8(%rip),%rdi
lea    0x7c3(%rip),%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r14),%eax
test   %eax,(%r12)
je     199a <logEvent+0x84a>
mov    0x18(%r14),%edi
call   1060 <rmWatch@plt>
mov    (%r14),%eax
mov    0x2607(%rip),%rcx
test   %eax,(%rcx)
je     19f7 <logEvent+0x8a7>
test   %eax,(%r15)
je     19f7 <logEvent+0x8a7>
mov    %rsp,%r12
mov    0x2634(%rip),%rax
mov    (%rax),%ecx
mov    %rsp,%rbx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rbx
mov    %rbx,%rsp
mov    (%rax),%r15d
mov    0x18(%r14),%edi
call   1030 <pathPrefix@plt>
mov    0x10(%r14),%r8
lea    0x76e(%rip),%rdx
mov    %rbx,%rdi
mov    %r15d,%esi
mov    %rax,%rcx
call   1050 <snprintf@plt>
mov    %rbx,%rdi
call   1070 <addWatch@plt>
mov    %r12,%rsp
lea    -0x20(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.inotify_event = type { i32, i64, i8*, i32 }
@IN_ACCESS = global i32 0
@.str = [6 x i8] c"[%s] \00"
@.str.1 = [5 x i8] c"INFO\00"
@IN_ISDIR = global i32 0
@.str.2 = [20 x i8] c"Directory %s/%s %s\0A\00"
@.str.3 = [13 x i8] c"was accessed\00"
@.str.4 = [15 x i8] c"File %s/%s %s\0A\00"
@.str.5 = [17 x i8] c"Directory %s %s\0A\00"
@IN_ATTRIB = global i32 0
@.str.6 = [25 x i8] c"had its metadata changed\00"
@IN_CLOSE_NOWRITE = global i32 0
@.str.7 = [23 x i8] c"was closed (read-only)\00"
@IN_CLOSE_WRITE = global i32 0
@.str.8 = [11 x i8] c"was closed\00"
@IN_CREATE = global i32 0
@.str.9 = [12 x i8] c"was created\00"
@IN_DELETE = global i32 0
@.str.10 = [12 x i8] c"was deleted\00"
@IN_DELETE_SELF = global i32 0
@.str.11 = [8 x i8] c"WARNING\00"
@.str.12 = [32 x i8] c"was deleted (watched directory)\00"
@IN_IGNORED = global i32 0
@.str.13 = [51 x i8] c"is no longer being watched (maybe it was deleted?)\00"
@IN_MODIFY = global i32 0
@.str.14 = [13 x i8] c"was modified\00"
@IN_MOVE_SELF = global i32 0
@.str.15 = [10 x i8] c"was moved\00"
@IN_MOVED_FROM = global i32 0
@IN_MOVED_TO = global i32 0
@IN_OPEN = global i32 0
@.str.16 = [11 x i8] c"was opened\00"
@IN_Q_OVERFLOW = global i32 0
@.str.17 = [6 x i8] c"FATAL\00"
@.str.18 = [28 x i8] c"too many queued file events\00"
@IN_UNMOUNT = global i32 0
@.str.19 = [14 x i8] c"was unmounted\00"
@PATH_MAX = global i32 0
@.str.20 = [6 x i8] c"%s/%s\00"
define void @logEvent(%struct.inotify_event* %0) {
%2 = alloca %struct.inotify_event*
%3 = alloca i8*
%4 = alloca i64
store %struct.inotify_event* %0, %struct.inotify_event** %2
%5 = load %struct.inotify_event*, %struct.inotify_event** %2
%6 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %5, i32 0, i32 0
%7 = load i32, i32* %6
%8 = load i32, i32* @IN_ACCESS
%9 = and i32 %7, %8
%10 = icmp ne i32 %9, 0
br i1 %10, label %11, label %50
11: ; preds = %1
%12 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%13 = load %struct.inotify_event*, %struct.inotify_event** %2
%14 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %13, i32 0, i32 1
%15 = load i64, i64* %14
%16 = icmp sgt i64 %15, 0
br i1 %16, label %17, label %43
17: ; preds = %11
%18 = load %struct.inotify_event*, %struct.inotify_event** %2
%19 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %18, i32 0, i32 0
%20 = load i32, i32* %19
%21 = load i32, i32* @IN_ISDIR
%22 = and i32 %20, %21
%23 = icmp ne i32 %22, 0
br i1 %23, label %24, label %33
24: ; preds = %17
%25 = load %struct.inotify_event*, %struct.inotify_event** %2
%26 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %25, i32 0, i32 3
%27 = load i32, i32* %26
%28 = call i8* @pathPrefix(i32 %27)
%29 = load %struct.inotify_event*, %struct.inotify_event** %2
%30 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %29, i32 0, i32 2
%31 = load i8*, i8** %30
%32 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %28, i8* %31, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0))
br label %42
33: ; preds = %17
%34 = load %struct.inotify_event*, %struct.inotify_event** %2
%35 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %34, i32 0, i32 3
%36 = load i32, i32* %35
%37 = call i8* @pathPrefix(i32 %36)
%38 = load %struct.inotify_event*, %struct.inotify_event** %2
%39 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %38, i32 0, i32 2
%40 = load i8*, i8** %39
%41 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %37, i8* %40, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0))
br label %42
42: ; preds = %33, %24
br label %49
43: ; preds = %11
%44 = load %struct.inotify_event*, %struct.inotify_event** %2
%45 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %44, i32 0, i32 3
%46 = load i32, i32* %45
%47 = call i8* @pathPrefix(i32 %46)
%48 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %47, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0))
br label %49
49: ; preds = %43, %42
br label %50
50: ; preds = %49, %1
%51 = load %struct.inotify_event*, %struct.inotify_event** %2
%52 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %51, i32 0, i32 0
%53 = load i32, i32* %52
%54 = load i32, i32* @IN_ATTRIB
%55 = and i32 %53, %54
%56 = icmp ne i32 %55, 0
br i1 %56, label %57, label %96
57: ; preds = %50
%58 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%59 = load %struct.inotify_event*, %struct.inotify_event** %2
%60 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %59, i32 0, i32 1
%61 = load i64, i64* %60
%62 = icmp sgt i64 %61, 0
br i1 %62, label %63, label %89
63: ; preds = %57
%64 = load %struct.inotify_event*, %struct.inotify_event** %2
%65 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %64, i32 0, i32 0
%66 = load i32, i32* %65
%67 = load i32, i32* @IN_ISDIR
%68 = and i32 %66, %67
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %79
70: ; preds = %63
%71 = load %struct.inotify_event*, %struct.inotify_event** %2
%72 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %71, i32 0, i32 3
%73 = load i32, i32* %72
%74 = call i8* @pathPrefix(i32 %73)
%75 = load %struct.inotify_event*, %struct.inotify_event** %2
%76 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %75, i32 0, i32 2
%77 = load i8*, i8** %76
%78 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %74, i8* %77, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.6, i64 0, i64 0))
br label %88
79: ; preds = %63
%80 = load %struct.inotify_event*, %struct.inotify_event** %2
%81 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %80, i32 0, i32 3
%82 = load i32, i32* %81
%83 = call i8* @pathPrefix(i32 %82)
%84 = load %struct.inotify_event*, %struct.inotify_event** %2
%85 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %84, i32 0, i32 2
%86 = load i8*, i8** %85
%87 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %83, i8* %86, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.6, i64 0, i64 0))
br label %88
88: ; preds = %79, %70
br label %95
89: ; preds = %57
%90 = load %struct.inotify_event*, %struct.inotify_event** %2
%91 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %90, i32 0, i32 3
%92 = load i32, i32* %91
%93 = call i8* @pathPrefix(i32 %92)
%94 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %93, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.6, i64 0, i64 0))
br label %95
95: ; preds = %89, %88
br label %96
96: ; preds = %95, %50
%97 = load %struct.inotify_event*, %struct.inotify_event** %2
%98 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %97, i32 0, i32 0
%99 = load i32, i32* %98
%100 = load i32, i32* @IN_CLOSE_NOWRITE
%101 = and i32 %99, %100
%102 = icmp ne i32 %101, 0
br i1 %102, label %103, label %142
103: ; preds = %96
%104 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%105 = load %struct.inotify_event*, %struct.inotify_event** %2
%106 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %105, i32 0, i32 1
%107 = load i64, i64* %106
%108 = icmp sgt i64 %107, 0
br i1 %108, label %109, label %135
109: ; preds = %103
%110 = load %struct.inotify_event*, %struct.inotify_event** %2
%111 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %110, i32 0, i32 0
%112 = load i32, i32* %111
%113 = load i32, i32* @IN_ISDIR
%114 = and i32 %112, %113
%115 = icmp ne i32 %114, 0
br i1 %115, label %116, label %125
116: ; preds = %109
%117 = load %struct.inotify_event*, %struct.inotify_event** %2
%118 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %117, i32 0, i32 3
%119 = load i32, i32* %118
%120 = call i8* @pathPrefix(i32 %119)
%121 = load %struct.inotify_event*, %struct.inotify_event** %2
%122 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %121, i32 0, i32 2
%123 = load i8*, i8** %122
%124 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %120, i8* %123, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.7, i64 0, i64 0))
br label %134
125: ; preds = %109
%126 = load %struct.inotify_event*, %struct.inotify_event** %2
%127 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %126, i32 0, i32 3
%128 = load i32, i32* %127
%129 = call i8* @pathPrefix(i32 %128)
%130 = load %struct.inotify_event*, %struct.inotify_event** %2
%131 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %130, i32 0, i32 2
%132 = load i8*, i8** %131
%133 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %129, i8* %132, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.7, i64 0, i64 0))
br label %134
134: ; preds = %125, %116
br label %141
135: ; preds = %103
%136 = load %struct.inotify_event*, %struct.inotify_event** %2
%137 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %136, i32 0, i32 3
%138 = load i32, i32* %137
%139 = call i8* @pathPrefix(i32 %138)
%140 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %139, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.7, i64 0, i64 0))
br label %141
141: ; preds = %135, %134
br label %142
142: ; preds = %141, %96
%143 = load %struct.inotify_event*, %struct.inotify_event** %2
%144 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %143, i32 0, i32 0
%145 = load i32, i32* %144
%146 = load i32, i32* @IN_CLOSE_WRITE
%147 = and i32 %145, %146
%148 = icmp ne i32 %147, 0
br i1 %148, label %149, label %188
149: ; preds = %142
%150 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%151 = load %struct.inotify_event*, %struct.inotify_event** %2
%152 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %151, i32 0, i32 1
%153 = load i64, i64* %152
%154 = icmp sgt i64 %153, 0
br i1 %154, label %155, label %181
155: ; preds = %149
%156 = load %struct.inotify_event*, %struct.inotify_event** %2
%157 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %156, i32 0, i32 0
%158 = load i32, i32* %157
%159 = load i32, i32* @IN_ISDIR
%160 = and i32 %158, %159
%161 = icmp ne i32 %160, 0
br i1 %161, label %162, label %171
162: ; preds = %155
%163 = load %struct.inotify_event*, %struct.inotify_event** %2
%164 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %163, i32 0, i32 3
%165 = load i32, i32* %164
%166 = call i8* @pathPrefix(i32 %165)
%167 = load %struct.inotify_event*, %struct.inotify_event** %2
%168 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %167, i32 0, i32 2
%169 = load i8*, i8** %168
%170 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %166, i8* %169, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0))
br label %180
171: ; preds = %155
%172 = load %struct.inotify_event*, %struct.inotify_event** %2
%173 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %172, i32 0, i32 3
%174 = load i32, i32* %173
%175 = call i8* @pathPrefix(i32 %174)
%176 = load %struct.inotify_event*, %struct.inotify_event** %2
%177 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %176, i32 0, i32 2
%178 = load i8*, i8** %177
%179 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %175, i8* %178, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0))
br label %180
180: ; preds = %171, %162
br label %187
181: ; preds = %149
%182 = load %struct.inotify_event*, %struct.inotify_event** %2
%183 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %182, i32 0, i32 3
%184 = load i32, i32* %183
%185 = call i8* @pathPrefix(i32 %184)
%186 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %185, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0))
br label %187
187: ; preds = %181, %180
br label %188
188: ; preds = %187, %142
%189 = load %struct.inotify_event*, %struct.inotify_event** %2
%190 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %189, i32 0, i32 0
%191 = load i32, i32* %190
%192 = load i32, i32* @IN_CREATE
%193 = and i32 %191, %192
%194 = icmp ne i32 %193, 0
br i1 %194, label %195, label %234
195: ; preds = %188
%196 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%197 = load %struct.inotify_event*, %struct.inotify_event** %2
%198 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %197, i32 0, i32 1
%199 = load i64, i64* %198
%200 = icmp sgt i64 %199, 0
br i1 %200, label %201, label %227
201: ; preds = %195
%202 = load %struct.inotify_event*, %struct.inotify_event** %2
%203 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %202, i32 0, i32 0
%204 = load i32, i32* %203
%205 = load i32, i32* @IN_ISDIR
%206 = and i32 %204, %205
%207 = icmp ne i32 %206, 0
br i1 %207, label %208, label %217
208: ; preds = %201
%209 = load %struct.inotify_event*, %struct.inotify_event** %2
%210 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %209, i32 0, i32 3
%211 = load i32, i32* %210
%212 = call i8* @pathPrefix(i32 %211)
%213 = load %struct.inotify_event*, %struct.inotify_event** %2
%214 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %213, i32 0, i32 2
%215 = load i8*, i8** %214
%216 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %212, i8* %215, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0))
br label %226
217: ; preds = %201
%218 = load %struct.inotify_event*, %struct.inotify_event** %2
%219 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %218, i32 0, i32 3
%220 = load i32, i32* %219
%221 = call i8* @pathPrefix(i32 %220)
%222 = load %struct.inotify_event*, %struct.inotify_event** %2
%223 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %222, i32 0, i32 2
%224 = load i8*, i8** %223
%225 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %221, i8* %224, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0))
br label %226
226: ; preds = %217, %208
br label %233
227: ; preds = %195
%228 = load %struct.inotify_event*, %struct.inotify_event** %2
%229 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %228, i32 0, i32 3
%230 = load i32, i32* %229
%231 = call i8* @pathPrefix(i32 %230)
%232 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %231, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0))
br label %233
233: ; preds = %227, %226
br label %234
234: ; preds = %233, %188
%235 = load %struct.inotify_event*, %struct.inotify_event** %2
%236 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %235, i32 0, i32 0
%237 = load i32, i32* %236
%238 = load i32, i32* @IN_DELETE
%239 = and i32 %237, %238
%240 = icmp ne i32 %239, 0
br i1 %240, label %241, label %280
241: ; preds = %234
%242 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%243 = load %struct.inotify_event*, %struct.inotify_event** %2
%244 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %243, i32 0, i32 1
%245 = load i64, i64* %244
%246 = icmp sgt i64 %245, 0
br i1 %246, label %247, label %273
247: ; preds = %241
%248 = load %struct.inotify_event*, %struct.inotify_event** %2
%249 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %248, i32 0, i32 0
%250 = load i32, i32* %249
%251 = load i32, i32* @IN_ISDIR
%252 = and i32 %250, %251
%253 = icmp ne i32 %252, 0
br i1 %253, label %254, label %263
254: ; preds = %247
%255 = load %struct.inotify_event*, %struct.inotify_event** %2
%256 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %255, i32 0, i32 3
%257 = load i32, i32* %256
%258 = call i8* @pathPrefix(i32 %257)
%259 = load %struct.inotify_event*, %struct.inotify_event** %2
%260 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %259, i32 0, i32 2
%261 = load i8*, i8** %260
%262 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %258, i8* %261, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.10, i64 0, i64 0))
br label %272
263: ; preds = %247
%264 = load %struct.inotify_event*, %struct.inotify_event** %2
%265 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %264, i32 0, i32 3
%266 = load i32, i32* %265
%267 = call i8* @pathPrefix(i32 %266)
%268 = load %struct.inotify_event*, %struct.inotify_event** %2
%269 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %268, i32 0, i32 2
%270 = load i8*, i8** %269
%271 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %267, i8* %270, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.10, i64 0, i64 0))
br label %272
272: ; preds = %263, %254
br label %279
273: ; preds = %241
%274 = load %struct.inotify_event*, %struct.inotify_event** %2
%275 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %274, i32 0, i32 3
%276 = load i32, i32* %275
%277 = call i8* @pathPrefix(i32 %276)
%278 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %277, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.10, i64 0, i64 0))
br label %279
279: ; preds = %273, %272
br label %280
280: ; preds = %279, %234
%281 = load %struct.inotify_event*, %struct.inotify_event** %2
%282 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %281, i32 0, i32 0
%283 = load i32, i32* %282
%284 = load i32, i32* @IN_DELETE_SELF
%285 = and i32 %283, %284
%286 = icmp ne i32 %285, 0
br i1 %286, label %287, label %326
287: ; preds = %280
%288 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.11, i64 0, i64 0))
%289 = load %struct.inotify_event*, %struct.inotify_event** %2
%290 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %289, i32 0, i32 1
%291 = load i64, i64* %290
%292 = icmp sgt i64 %291, 0
br i1 %292, label %293, label %319
293: ; preds = %287
%294 = load %struct.inotify_event*, %struct.inotify_event** %2
%295 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %294, i32 0, i32 0
%296 = load i32, i32* %295
%297 = load i32, i32* @IN_ISDIR
%298 = and i32 %296, %297
%299 = icmp ne i32 %298, 0
br i1 %299, label %300, label %309
300: ; preds = %293
%301 = load %struct.inotify_event*, %struct.inotify_event** %2
%302 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %301, i32 0, i32 3
%303 = load i32, i32* %302
%304 = call i8* @pathPrefix(i32 %303)
%305 = load %struct.inotify_event*, %struct.inotify_event** %2
%306 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %305, i32 0, i32 2
%307 = load i8*, i8** %306
%308 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %304, i8* %307, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.12, i64 0, i64 0))
br label %318
309: ; preds = %293
%310 = load %struct.inotify_event*, %struct.inotify_event** %2
%311 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %310, i32 0, i32 3
%312 = load i32, i32* %311
%313 = call i8* @pathPrefix(i32 %312)
%314 = load %struct.inotify_event*, %struct.inotify_event** %2
%315 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %314, i32 0, i32 2
%316 = load i8*, i8** %315
%317 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %313, i8* %316, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.12, i64 0, i64 0))
br label %318
318: ; preds = %309, %300
br label %325
319: ; preds = %287
%320 = load %struct.inotify_event*, %struct.inotify_event** %2
%321 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %320, i32 0, i32 3
%322 = load i32, i32* %321
%323 = call i8* @pathPrefix(i32 %322)
%324 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %323, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.12, i64 0, i64 0))
br label %325
325: ; preds = %319, %318
br label %326
326: ; preds = %325, %280
%327 = load %struct.inotify_event*, %struct.inotify_event** %2
%328 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %327, i32 0, i32 0
%329 = load i32, i32* %328
%330 = load i32, i32* @IN_IGNORED
%331 = and i32 %329, %330
%332 = icmp ne i32 %331, 0
br i1 %332, label %333, label %372
333: ; preds = %326
%334 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.11, i64 0, i64 0))
%335 = load %struct.inotify_event*, %struct.inotify_event** %2
%336 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %335, i32 0, i32 1
%337 = load i64, i64* %336
%338 = icmp sgt i64 %337, 0
br i1 %338, label %339, label %365
339: ; preds = %333
%340 = load %struct.inotify_event*, %struct.inotify_event** %2
%341 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %340, i32 0, i32 0
%342 = load i32, i32* %341
%343 = load i32, i32* @IN_ISDIR
%344 = and i32 %342, %343
%345 = icmp ne i32 %344, 0
br i1 %345, label %346, label %355
346: ; preds = %339
%347 = load %struct.inotify_event*, %struct.inotify_event** %2
%348 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %347, i32 0, i32 3
%349 = load i32, i32* %348
%350 = call i8* @pathPrefix(i32 %349)
%351 = load %struct.inotify_event*, %struct.inotify_event** %2
%352 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %351, i32 0, i32 2
%353 = load i8*, i8** %352
%354 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %350, i8* %353, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.13, i64 0, i64 0))
br label %364
355: ; preds = %339
%356 = load %struct.inotify_event*, %struct.inotify_event** %2
%357 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %356, i32 0, i32 3
%358 = load i32, i32* %357
%359 = call i8* @pathPrefix(i32 %358)
%360 = load %struct.inotify_event*, %struct.inotify_event** %2
%361 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %360, i32 0, i32 2
%362 = load i8*, i8** %361
%363 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %359, i8* %362, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.13, i64 0, i64 0))
br label %364
364: ; preds = %355, %346
br label %371
365: ; preds = %333
%366 = load %struct.inotify_event*, %struct.inotify_event** %2
%367 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %366, i32 0, i32 3
%368 = load i32, i32* %367
%369 = call i8* @pathPrefix(i32 %368)
%370 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %369, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.13, i64 0, i64 0))
br label %371
371: ; preds = %365, %364
br label %372
372: ; preds = %371, %326
%373 = load %struct.inotify_event*, %struct.inotify_event** %2
%374 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %373, i32 0, i32 0
%375 = load i32, i32* %374
%376 = load i32, i32* @IN_MODIFY
%377 = and i32 %375, %376
%378 = icmp ne i32 %377, 0
br i1 %378, label %379, label %418
379: ; preds = %372
%380 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%381 = load %struct.inotify_event*, %struct.inotify_event** %2
%382 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %381, i32 0, i32 1
%383 = load i64, i64* %382
%384 = icmp sgt i64 %383, 0
br i1 %384, label %385, label %411
385: ; preds = %379
%386 = load %struct.inotify_event*, %struct.inotify_event** %2
%387 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %386, i32 0, i32 0
%388 = load i32, i32* %387
%389 = load i32, i32* @IN_ISDIR
%390 = and i32 %388, %389
%391 = icmp ne i32 %390, 0
br i1 %391, label %392, label %401
392: ; preds = %385
%393 = load %struct.inotify_event*, %struct.inotify_event** %2
%394 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %393, i32 0, i32 3
%395 = load i32, i32* %394
%396 = call i8* @pathPrefix(i32 %395)
%397 = load %struct.inotify_event*, %struct.inotify_event** %2
%398 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %397, i32 0, i32 2
%399 = load i8*, i8** %398
%400 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %396, i8* %399, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.14, i64 0, i64 0))
br label %410
401: ; preds = %385
%402 = load %struct.inotify_event*, %struct.inotify_event** %2
%403 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %402, i32 0, i32 3
%404 = load i32, i32* %403
%405 = call i8* @pathPrefix(i32 %404)
%406 = load %struct.inotify_event*, %struct.inotify_event** %2
%407 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %406, i32 0, i32 2
%408 = load i8*, i8** %407
%409 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %405, i8* %408, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.14, i64 0, i64 0))
br label %410
410: ; preds = %401, %392
br label %417
411: ; preds = %379
%412 = load %struct.inotify_event*, %struct.inotify_event** %2
%413 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %412, i32 0, i32 3
%414 = load i32, i32* %413
%415 = call i8* @pathPrefix(i32 %414)
%416 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %415, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.14, i64 0, i64 0))
br label %417
417: ; preds = %411, %410
br label %418
418: ; preds = %417, %372
%419 = load %struct.inotify_event*, %struct.inotify_event** %2
%420 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %419, i32 0, i32 0
%421 = load i32, i32* %420
%422 = load i32, i32* @IN_MOVE_SELF
%423 = and i32 %421, %422
%424 = icmp ne i32 %423, 0
br i1 %424, label %425, label %464
425: ; preds = %418
%426 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%427 = load %struct.inotify_event*, %struct.inotify_event** %2
%428 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %427, i32 0, i32 1
%429 = load i64, i64* %428
%430 = icmp sgt i64 %429, 0
br i1 %430, label %431, label %457
431: ; preds = %425
%432 = load %struct.inotify_event*, %struct.inotify_event** %2
%433 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %432, i32 0, i32 0
%434 = load i32, i32* %433
%435 = load i32, i32* @IN_ISDIR
%436 = and i32 %434, %435
%437 = icmp ne i32 %436, 0
br i1 %437, label %438, label %447
438: ; preds = %431
%439 = load %struct.inotify_event*, %struct.inotify_event** %2
%440 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %439, i32 0, i32 3
%441 = load i32, i32* %440
%442 = call i8* @pathPrefix(i32 %441)
%443 = load %struct.inotify_event*, %struct.inotify_event** %2
%444 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %443, i32 0, i32 2
%445 = load i8*, i8** %444
%446 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %442, i8* %445, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %456
447: ; preds = %431
%448 = load %struct.inotify_event*, %struct.inotify_event** %2
%449 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %448, i32 0, i32 3
%450 = load i32, i32* %449
%451 = call i8* @pathPrefix(i32 %450)
%452 = load %struct.inotify_event*, %struct.inotify_event** %2
%453 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %452, i32 0, i32 2
%454 = load i8*, i8** %453
%455 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %451, i8* %454, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %456
456: ; preds = %447, %438
br label %463
457: ; preds = %425
%458 = load %struct.inotify_event*, %struct.inotify_event** %2
%459 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %458, i32 0, i32 3
%460 = load i32, i32* %459
%461 = call i8* @pathPrefix(i32 %460)
%462 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %461, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %463
463: ; preds = %457, %456
br label %464
464: ; preds = %463, %418
%465 = load %struct.inotify_event*, %struct.inotify_event** %2
%466 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %465, i32 0, i32 0
%467 = load i32, i32* %466
%468 = load i32, i32* @IN_MOVED_FROM
%469 = and i32 %467, %468
%470 = icmp ne i32 %469, 0
br i1 %470, label %471, label %510
471: ; preds = %464
%472 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%473 = load %struct.inotify_event*, %struct.inotify_event** %2
%474 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %473, i32 0, i32 1
%475 = load i64, i64* %474
%476 = icmp sgt i64 %475, 0
br i1 %476, label %477, label %503
477: ; preds = %471
%478 = load %struct.inotify_event*, %struct.inotify_event** %2
%479 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %478, i32 0, i32 0
%480 = load i32, i32* %479
%481 = load i32, i32* @IN_ISDIR
%482 = and i32 %480, %481
%483 = icmp ne i32 %482, 0
br i1 %483, label %484, label %493
484: ; preds = %477
%485 = load %struct.inotify_event*, %struct.inotify_event** %2
%486 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %485, i32 0, i32 3
%487 = load i32, i32* %486
%488 = call i8* @pathPrefix(i32 %487)
%489 = load %struct.inotify_event*, %struct.inotify_event** %2
%490 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %489, i32 0, i32 2
%491 = load i8*, i8** %490
%492 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %488, i8* %491, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %502
493: ; preds = %477
%494 = load %struct.inotify_event*, %struct.inotify_event** %2
%495 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %494, i32 0, i32 3
%496 = load i32, i32* %495
%497 = call i8* @pathPrefix(i32 %496)
%498 = load %struct.inotify_event*, %struct.inotify_event** %2
%499 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %498, i32 0, i32 2
%500 = load i8*, i8** %499
%501 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %497, i8* %500, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %502
502: ; preds = %493, %484
br label %509
503: ; preds = %471
%504 = load %struct.inotify_event*, %struct.inotify_event** %2
%505 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %504, i32 0, i32 3
%506 = load i32, i32* %505
%507 = call i8* @pathPrefix(i32 %506)
%508 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %507, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %509
509: ; preds = %503, %502
br label %510
510: ; preds = %509, %464
%511 = load %struct.inotify_event*, %struct.inotify_event** %2
%512 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %511, i32 0, i32 0
%513 = load i32, i32* %512
%514 = load i32, i32* @IN_MOVED_TO
%515 = and i32 %513, %514
%516 = icmp ne i32 %515, 0
br i1 %516, label %517, label %556
517: ; preds = %510
%518 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%519 = load %struct.inotify_event*, %struct.inotify_event** %2
%520 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %519, i32 0, i32 1
%521 = load i64, i64* %520
%522 = icmp sgt i64 %521, 0
br i1 %522, label %523, label %549
523: ; preds = %517
%524 = load %struct.inotify_event*, %struct.inotify_event** %2
%525 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %524, i32 0, i32 0
%526 = load i32, i32* %525
%527 = load i32, i32* @IN_ISDIR
%528 = and i32 %526, %527
%529 = icmp ne i32 %528, 0
br i1 %529, label %530, label %539
530: ; preds = %523
%531 = load %struct.inotify_event*, %struct.inotify_event** %2
%532 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %531, i32 0, i32 3
%533 = load i32, i32* %532
%534 = call i8* @pathPrefix(i32 %533)
%535 = load %struct.inotify_event*, %struct.inotify_event** %2
%536 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %535, i32 0, i32 2
%537 = load i8*, i8** %536
%538 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %534, i8* %537, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %548
539: ; preds = %523
%540 = load %struct.inotify_event*, %struct.inotify_event** %2
%541 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %540, i32 0, i32 3
%542 = load i32, i32* %541
%543 = call i8* @pathPrefix(i32 %542)
%544 = load %struct.inotify_event*, %struct.inotify_event** %2
%545 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %544, i32 0, i32 2
%546 = load i8*, i8** %545
%547 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %543, i8* %546, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %548
548: ; preds = %539, %530
br label %555
549: ; preds = %517
%550 = load %struct.inotify_event*, %struct.inotify_event** %2
%551 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %550, i32 0, i32 3
%552 = load i32, i32* %551
%553 = call i8* @pathPrefix(i32 %552)
%554 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %553, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0))
br label %555
555: ; preds = %549, %548
br label %556
556: ; preds = %555, %510
%557 = load %struct.inotify_event*, %struct.inotify_event** %2
%558 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %557, i32 0, i32 0
%559 = load i32, i32* %558
%560 = load i32, i32* @IN_OPEN
%561 = and i32 %559, %560
%562 = icmp ne i32 %561, 0
br i1 %562, label %563, label %602
563: ; preds = %556
%564 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%565 = load %struct.inotify_event*, %struct.inotify_event** %2
%566 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %565, i32 0, i32 1
%567 = load i64, i64* %566
%568 = icmp sgt i64 %567, 0
br i1 %568, label %569, label %595
569: ; preds = %563
%570 = load %struct.inotify_event*, %struct.inotify_event** %2
%571 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %570, i32 0, i32 0
%572 = load i32, i32* %571
%573 = load i32, i32* @IN_ISDIR
%574 = and i32 %572, %573
%575 = icmp ne i32 %574, 0
br i1 %575, label %576, label %585
576: ; preds = %569
%577 = load %struct.inotify_event*, %struct.inotify_event** %2
%578 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %577, i32 0, i32 3
%579 = load i32, i32* %578
%580 = call i8* @pathPrefix(i32 %579)
%581 = load %struct.inotify_event*, %struct.inotify_event** %2
%582 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %581, i32 0, i32 2
%583 = load i8*, i8** %582
%584 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %580, i8* %583, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0))
br label %594
585: ; preds = %569
%586 = load %struct.inotify_event*, %struct.inotify_event** %2
%587 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %586, i32 0, i32 3
%588 = load i32, i32* %587
%589 = call i8* @pathPrefix(i32 %588)
%590 = load %struct.inotify_event*, %struct.inotify_event** %2
%591 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %590, i32 0, i32 2
%592 = load i8*, i8** %591
%593 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %589, i8* %592, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0))
br label %594
594: ; preds = %585, %576
br label %601
595: ; preds = %563
%596 = load %struct.inotify_event*, %struct.inotify_event** %2
%597 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %596, i32 0, i32 3
%598 = load i32, i32* %597
%599 = call i8* @pathPrefix(i32 %598)
%600 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %599, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0))
br label %601
601: ; preds = %595, %594
br label %602
602: ; preds = %601, %556
%603 = load %struct.inotify_event*, %struct.inotify_event** %2
%604 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %603, i32 0, i32 0
%605 = load i32, i32* %604
%606 = load i32, i32* @IN_Q_OVERFLOW
%607 = and i32 %605, %606
%608 = icmp ne i32 %607, 0
br i1 %608, label %609, label %648
609: ; preds = %602
%610 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.17, i64 0, i64 0))
%611 = load %struct.inotify_event*, %struct.inotify_event** %2
%612 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %611, i32 0, i32 1
%613 = load i64, i64* %612
%614 = icmp sgt i64 %613, 0
br i1 %614, label %615, label %641
615: ; preds = %609
%616 = load %struct.inotify_event*, %struct.inotify_event** %2
%617 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %616, i32 0, i32 0
%618 = load i32, i32* %617
%619 = load i32, i32* @IN_ISDIR
%620 = and i32 %618, %619
%621 = icmp ne i32 %620, 0
br i1 %621, label %622, label %631
622: ; preds = %615
%623 = load %struct.inotify_event*, %struct.inotify_event** %2
%624 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %623, i32 0, i32 3
%625 = load i32, i32* %624
%626 = call i8* @pathPrefix(i32 %625)
%627 = load %struct.inotify_event*, %struct.inotify_event** %2
%628 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %627, i32 0, i32 2
%629 = load i8*, i8** %628
%630 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %626, i8* %629, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.18, i64 0, i64 0))
br label %640
631: ; preds = %615
%632 = load %struct.inotify_event*, %struct.inotify_event** %2
%633 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %632, i32 0, i32 3
%634 = load i32, i32* %633
%635 = call i8* @pathPrefix(i32 %634)
%636 = load %struct.inotify_event*, %struct.inotify_event** %2
%637 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %636, i32 0, i32 2
%638 = load i8*, i8** %637
%639 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %635, i8* %638, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.18, i64 0, i64 0))
br label %640
640: ; preds = %631, %622
br label %647
641: ; preds = %609
%642 = load %struct.inotify_event*, %struct.inotify_event** %2
%643 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %642, i32 0, i32 3
%644 = load i32, i32* %643
%645 = call i8* @pathPrefix(i32 %644)
%646 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %645, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.18, i64 0, i64 0))
br label %647
647: ; preds = %641, %640
br label %648
648: ; preds = %647, %602
%649 = load %struct.inotify_event*, %struct.inotify_event** %2
%650 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %649, i32 0, i32 0
%651 = load i32, i32* %650
%652 = load i32, i32* @IN_UNMOUNT
%653 = and i32 %651, %652
%654 = icmp ne i32 %653, 0
br i1 %654, label %655, label %694
655: ; preds = %648
%656 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%657 = load %struct.inotify_event*, %struct.inotify_event** %2
%658 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %657, i32 0, i32 1
%659 = load i64, i64* %658
%660 = icmp sgt i64 %659, 0
br i1 %660, label %661, label %687
661: ; preds = %655
%662 = load %struct.inotify_event*, %struct.inotify_event** %2
%663 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %662, i32 0, i32 0
%664 = load i32, i32* %663
%665 = load i32, i32* @IN_ISDIR
%666 = and i32 %664, %665
%667 = icmp ne i32 %666, 0
br i1 %667, label %668, label %677
668: ; preds = %661
%669 = load %struct.inotify_event*, %struct.inotify_event** %2
%670 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %669, i32 0, i32 3
%671 = load i32, i32* %670
%672 = call i8* @pathPrefix(i32 %671)
%673 = load %struct.inotify_event*, %struct.inotify_event** %2
%674 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %673, i32 0, i32 2
%675 = load i8*, i8** %674
%676 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i8* %672, i8* %675, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.19, i64 0, i64 0))
br label %686
677: ; preds = %661
%678 = load %struct.inotify_event*, %struct.inotify_event** %2
%679 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %678, i32 0, i32 3
%680 = load i32, i32* %679
%681 = call i8* @pathPrefix(i32 %680)
%682 = load %struct.inotify_event*, %struct.inotify_event** %2
%683 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %682, i32 0, i32 2
%684 = load i8*, i8** %683
%685 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), i8* %681, i8* %684, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.19, i64 0, i64 0))
br label %686
686: ; preds = %677, %668
br label %693
687: ; preds = %655
%688 = load %struct.inotify_event*, %struct.inotify_event** %2
%689 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %688, i32 0, i32 3
%690 = load i32, i32* %689
%691 = call i8* @pathPrefix(i32 %690)
%692 = call i32 (i8*, i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* %691, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.19, i64 0, i64 0))
br label %693
693: ; preds = %687, %686
br label %694
694: ; preds = %693, %648
%695 = load %struct.inotify_event*, %struct.inotify_event** %2
%696 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %695, i32 0, i32 0
%697 = load i32, i32* %696
%698 = load i32, i32* @IN_IGNORED
%699 = and i32 %697, %698
%700 = icmp ne i32 %699, 0
br i1 %700, label %701, label %706
701: ; preds = %694
%702 = load %struct.inotify_event*, %struct.inotify_event** %2
%703 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %702, i32 0, i32 3
%704 = load i32, i32* %703
%705 = call i32 @rmWatch(i32 %704)
br label %706
706: ; preds = %701, %694
%707 = load %struct.inotify_event*, %struct.inotify_event** %2
%708 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %707, i32 0, i32 0
%709 = load i32, i32* %708
%710 = load i32, i32* @IN_ISDIR
%711 = and i32 %709, %710
%712 = icmp ne i32 %711, 0
br i1 %712, label %713, label %736
713: ; preds = %706
%714 = load %struct.inotify_event*, %struct.inotify_event** %2
%715 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %714, i32 0, i32 0
%716 = load i32, i32* %715
%717 = load i32, i32* @IN_CREATE
%718 = and i32 %716, %717
%719 = icmp ne i32 %718, 0
br i1 %719, label %720, label %736
720: ; preds = %713
%721 = load i32, i32* @PATH_MAX
%722 = zext i32 %721 to i64
%723 = call i8* @llvm.stacksave()
store i8* %723, i8** %3
%724 = alloca i8, i64 %722
store i64 %722, i64* %4
%725 = load i32, i32* @PATH_MAX
%726 = load %struct.inotify_event*, %struct.inotify_event** %2
%727 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %726, i32 0, i32 3
%728 = load i32, i32* %727
%729 = call i8* @pathPrefix(i32 %728)
%730 = load %struct.inotify_event*, %struct.inotify_event** %2
%731 = getelementptr inbounds %struct.inotify_event, %struct.inotify_event* %730, i32 0, i32 2
%732 = load i8*, i8** %731
%733 = call i32 @snprintf(i8* %724, i32 %725, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0), i8* %729, i8* %732)
%734 = call i32 @addWatch(i8* %724)
%735 = load i8*, i8** %3
br label %736
736: ; preds = %720, %713, %706
ret void
}

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