[deliverable/lttng-analyses.git] / lttng-track-process

#!/usr/bin/env python3
#
# Follow the execution of one or more processes throughout a LTTng trace and
# print a textual output similar to Babeltrace.
# When using the --procname option, the program tries to find the associated
# TID as soon as possible.
# The "follow-child" option only works for children started with fork after the
# beginning of the trace.
#
# When invoked without filtering arguments, all the events are displayed and an
# additionnal field at the beginning of the line shows the current TID allowing
# to easily grep/search in the text dump.
#
# To handle more events (including UST events), follow the comments below, most
# of this file has been autogenerated with parser_generator.py
#
# Note: unbelievably slow (140x slower than babeltrace), blame python and a lot
# of string comparisons, but still much faster than a brain and eyes.
#
#
# The MIT License (MIT)
#
# Copyright (C) 2015 - Julien Desfossez <jdesfossez@efficios.com>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

import sys
import time
import argparse

NSEC_PER_SEC = 1000000000

try:
    from babeltrace import TraceCollection
except ImportError:
    # quick fix for debian-based distros
    sys.path.append("/usr/local/lib/python%d.%d/site-packages" %
                    (sys.version_info.major, sys.version_info.minor))
    from babeltrace import TraceCollection


class TraceParser:
    def __init__(self, trace, arg_proc_list, arg_tid_list, arg_follow_child):
        self.trace = trace
        self.event_count = {}
        self.arg_proc_list = arg_proc_list
        self.arg_tid_list = arg_tid_list
        self.arg_follow_child = arg_follow_child
        self.per_cpu_current = {}

    def ns_to_hour_nsec(self, ns):
        d = time.localtime(ns/NSEC_PER_SEC)
        return "%02d:%02d:%02d.%09d" % (d.tm_hour, d.tm_min, d.tm_sec,
                                        ns % NSEC_PER_SEC)

    def check_procname(self, name, tid):
        if self.arg_proc_list is None:
            return
        if name in self.arg_proc_list:
            if self.arg_tid_list is None:
                self.arg_tid_list = []
            if not tid in self.arg_tid_list:
                self.arg_tid_list.append(int(tid))

    def tid_check(self, tid):
        if self.arg_tid_list is not None and tid in self.arg_tid_list:
            return True
        return False

    def filter_event(self, event):
        # no filtering
        if self.arg_tid_list is None and self.arg_proc_list is None:
            return True
        # we don't know yet the PID we are interested in (match procname - pid)
        if self.arg_tid_list is None:
            return False
        cpu_id = event["cpu_id"]
        if not cpu_id in self.per_cpu_current.keys():
            return False
        return self.tid_check(self.per_cpu_current[cpu_id])

    def get_tid_str(self, event):
        cpu_id = event["cpu_id"]
        if not cpu_id in self.per_cpu_current.keys():
            tid = "?"
        else:
            tid = self.per_cpu_current[cpu_id]
        return "[{:>6}]".format(tid)

    def print_filter(self, event, string):
        if event.name.startswith("lttng_statedump"):
            if "tid" in event.keys():
                if not self.tid_check(event["tid"]):
                    return
            elif "pid" in event.keys():
                if not self.tid_check(event["pid"]):
                    return
            else:
                return
        elif not self.filter_event(event):
            return
        print(self.get_tid_str(event), string)

    def handle_special_events(self, event):
        # events that need some mangling/processing
        cpu_id = event["cpu_id"]
        if event.name == "sched_switch":
            timestamp = event.timestamp
            cpu_id = event["cpu_id"]
            prev_comm = event["prev_comm"]
            prev_tid = event["prev_tid"]
            prev_prio = event["prev_prio"]
            prev_state = event["prev_state"]
            next_comm = event["next_comm"]
            next_tid = event["next_tid"]
            next_prio = event["next_prio"]

            if cpu_id not in self.per_cpu_current.keys():
                self.per_cpu_current[cpu_id] = next_tid
            else:
                self.per_cpu_current[cpu_id] = next_tid
            # we want to see the scheduling out
            if self.tid_check(prev_tid):
                print(self.get_tid_str(event), "[%s] %s: { cpu_id = %s }, { prev_comm = "
                      "%s, prev_tid = %s, prev_prio = %s, prev_state = %s, "
                      "next_comm = %s, next_tid = %s, next_prio = %s }" %
                      (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, prev_comm, prev_tid,
                      prev_prio, prev_state, next_comm, next_tid, next_prio,))
        elif event.name == "sched_process_exec":
            tid = event["tid"]
            filename = event["filename"]
            name = filename.split("/")[-1]
            self.check_procname(name, tid)
        elif event.name == "syscall_entry_execve":
            if not cpu_id in self.per_cpu_current.keys():
                return
            tid = self.per_cpu_current[cpu_id]
            filename = event["filename"]
            name = filename.split("/")[-1]
            self.check_procname(name, tid)
        elif event.name == "sched_process_fork" and self.arg_follow_child:
            pt = event["parent_tid"]
            pc = event["parent_comm"]
            ct = event["child_tid"]
            cc = event["child_comm"]
            if self.tid_check(pt) and ct not in self.arg_tid_list:
                self.arg_tid_list.append(ct)
            if self.arg_proc_list is not None and pc in self.arg_proc_list:
                self.arg_tid_list.append(ct)

    def parse(self):
        # iterate over all the events
        for event in self.trace.events:
            method_name = "handle_%s" % event.name.replace(":", "_").replace("+", "_")
            # call the function to handle each event individually
            if "comm" in event.keys() and "tid" in event.keys():
                self.check_procname(event["comm"], event["tid"])
            elif "name" in event.keys() and "tid" in event.keys():
                self.check_procname(event["name"], event["tid"])
            elif "next_comm" in event.keys() and "next_tid" in event.keys():
                self.check_procname(event["next_comm"], event["next_tid"])
            elif "prev_comm" in event.keys() and "prev_tid" in event.keys():
                self.check_procname(event["prev_comm"], event["prev_tid"])
            elif "parent_comm" in event.keys() and "parent_tid" in event.keys():
                self.check_procname(event["parent_comm"], event["parent_tid"])
            elif "child_comm" in event.keys() and "child_tid" in event.keys():
                self.check_procname(event["child_comm"], event["child_tid"])

            self.handle_special_events(event)

            if hasattr(TraceParser, method_name):
                func = getattr(TraceParser, method_name)
                func(self, event)

    # everything between here and the end of the class has been generated
    # with parser_generator.py on a trace with all kernel events enabled
    # and transformed with:
    # :%s/print("\[%s\]/self.print_filter(event, "[%s]/g
    # :%s/self.event_count\[event.name\] += 1\n//
    # :%s/                self.print_filter/        self.print_filter/g

    def handle_compat_syscall_exit_setns(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sendmmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_syncfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_clock_adjtime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        utx = event["utx"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, utx = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, utx,))

    def handle_compat_syscall_exit_prlimit64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        old_rlim = event["old_rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, old_rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, old_rlim,))

    def handle_compat_syscall_exit_fanotify_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_recvmmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        mmsg = event["mmsg"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, mmsg = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, mmsg, timeout,))

    def handle_compat_syscall_exit_perf_event_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_rt_tgsigqueueinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_pwritev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_preadv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, vec,))

    def handle_compat_syscall_exit_inotify_init1(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_pipe2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fildes = event["fildes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fildes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fildes,))

    def handle_compat_syscall_exit_dup3(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_epoll_create1(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_eventfd2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_signalfd4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_timerfd_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        otmr = event["otmr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, otmr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, otmr,))

    def handle_compat_syscall_exit_timerfd_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        otmr = event["otmr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, otmr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, otmr,))

    def handle_compat_syscall_exit_eventfd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_timerfd_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_signalfd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_utimensat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_epoll_pwait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        events = event["events"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, events = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, events,))

    def handle_compat_syscall_exit_getcpu(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        cpup = event["cpup"]
        nodep = event["nodep"]
        tcache = event["tcache"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, cpup = %s, nodep = %s, tcache = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, cpup, nodep, tcache,))

    def handle_compat_syscall_exit_vmsplice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_tee(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_splice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_get_robust_list(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        head_ptr = event["head_ptr"]
        len_ptr = event["len_ptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, head_ptr = %s, len_ptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, head_ptr, len_ptr,))

    def handle_compat_syscall_exit_set_robust_list(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_unshare(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_ppoll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ufds = event["ufds"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ufds = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ufds,))

    def handle_compat_syscall_exit_pselect6(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        inp = event["inp"]
        outp = event["outp"]
        exp = event["exp"]
        tsp = event["tsp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, inp = %s, outp = %s, exp = %s, tsp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, inp, outp, exp, tsp,))

    def handle_compat_syscall_exit_faccessat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fchmodat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_readlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_compat_syscall_exit_symlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_linkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_renameat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_unlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fstatat64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        dfd = event["dfd"]
        filename = event["filename"]
        statbuf = event["statbuf"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, dfd = %s, filename = %s, statbuf = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, dfd, filename, statbuf, flag,))

    def handle_compat_syscall_exit_futimesat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fchownat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mknodat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mkdirat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_openat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_inotify_rm_watch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_inotify_add_watch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_inotify_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_ioprio_get(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_ioprio_set(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_keyctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg2 = event["arg2"]
        arg3 = event["arg3"]
        arg4 = event["arg4"]
        arg5 = event["arg5"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg2 = %s, arg3 = %s, arg4 = %s, arg5 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg2, arg3, arg4, arg5,))

    def handle_compat_syscall_exit_request_key(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_add_key(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_waitid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        infop = event["infop"]
        ru = event["ru"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, infop = %s, ru = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, infop, ru,))

    def handle_compat_syscall_exit_kexec_load(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mq_getsetattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        u_omqstat = event["u_omqstat"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, u_omqstat = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, u_omqstat,))

    def handle_compat_syscall_exit_mq_notify(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mq_timedreceive(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        u_msg_ptr = event["u_msg_ptr"]
        u_msg_prio = event["u_msg_prio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, u_msg_ptr = %s, u_msg_prio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, u_msg_ptr, u_msg_prio,))

    def handle_compat_syscall_exit_mq_timedsend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mq_unlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mq_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_utimes(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_tgkill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fstatfs64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fd = event["fd"]
        sz = event["sz"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fd = %s, sz = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fd, sz, buf,))

    def handle_compat_syscall_exit_statfs64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        pathname = event["pathname"]
        sz = event["sz"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, pathname = %s, sz = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, pathname, sz, buf,))

    def handle_compat_syscall_exit_clock_nanosleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rmtp = event["rmtp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rmtp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rmtp,))

    def handle_compat_syscall_exit_clock_getres(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tp = event["tp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tp,))

    def handle_compat_syscall_exit_clock_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tp = event["tp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tp,))

    def handle_compat_syscall_exit_clock_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_timer_delete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_timer_getoverrun(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_timer_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        setting = event["setting"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, setting = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, setting,))

    def handle_compat_syscall_exit_timer_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        old_setting = event["old_setting"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, old_setting = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, old_setting,))

    def handle_compat_syscall_exit_timer_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        created_timer_id = event["created_timer_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, created_timer_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, created_timer_id,))

    def handle_compat_syscall_exit_set_tid_address(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_remap_file_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_epoll_wait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        events = event["events"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, events = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, events,))

    def handle_compat_syscall_exit_epoll_ctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_epoll_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_exit_group(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_io_cancel(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        result = event["result"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, result = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, result,))

    def handle_compat_syscall_exit_io_submit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_io_getevents(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        events = event["events"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, events = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, events, timeout,))

    def handle_compat_syscall_exit_io_destroy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_io_setup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sched_getaffinity(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        user_mask_ptr = event["user_mask_ptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, user_mask_ptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, user_mask_ptr,))

    def handle_compat_syscall_exit_sched_setaffinity(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_futex(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        uaddr = event["uaddr"]
        uaddr2 = event["uaddr2"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, uaddr = %s, uaddr2 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, uaddr, uaddr2,))

    def handle_compat_syscall_exit_sendfile64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        offset = event["offset"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, offset = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, offset,))

    def handle_compat_syscall_exit_tkill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fremovexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_lremovexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_removexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_flistxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        list = event["list"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, list = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, list,))

    def handle_compat_syscall_exit_llistxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        list = event["list"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, list = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, list,))

    def handle_compat_syscall_exit_listxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        list = event["list"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, list = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, list,))

    def handle_compat_syscall_exit_fgetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, value,))

    def handle_compat_syscall_exit_lgetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, value,))

    def handle_compat_syscall_exit_getxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, value,))

    def handle_compat_syscall_exit_fsetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_lsetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_gettid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fcntl64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fd = event["fd"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fd = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fd, cmd, arg,))

    def handle_compat_syscall_exit_getdents64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        dirent = event["dirent"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, dirent = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, dirent,))

    def handle_compat_syscall_exit_madvise(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mincore(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, vec,))

    def handle_compat_syscall_exit_pivot_root(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setfsgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setfsuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_chown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getresgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rgid = event["rgid"]
        egid = event["egid"]
        sgid = event["sgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rgid = %s, egid = %s, sgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rgid, egid, sgid,))

    def handle_compat_syscall_exit_setresgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getresuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ruid = event["ruid"]
        euid = event["euid"]
        suid = event["suid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ruid = %s, euid = %s, suid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ruid, euid, suid,))

    def handle_compat_syscall_exit_setresuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fchown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setgroups(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getgroups(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        grouplist = event["grouplist"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, grouplist = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, grouplist,))

    def handle_compat_syscall_exit_setregid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setreuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getegid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_geteuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_lchown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fstat64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fd = event["fd"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fd = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fd, statbuf,))

    def handle_compat_syscall_exit_lstat64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        filename = event["filename"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, filename = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, filename, statbuf,))

    def handle_compat_syscall_exit_stat64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        filename = event["filename"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, filename = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, filename, statbuf,))

    def handle_compat_syscall_exit_mmap_pgoff(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        addr = event["addr"]
        len = event["len"]
        prot = event["prot"]
        flags = event["flags"]
        fd = event["fd"]
        pgoff = event["pgoff"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, addr = %s, len = %s, prot = %s, flags = %s, fd = %s, pgoff = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, addr, len, prot, flags, fd, pgoff,))

    def handle_compat_syscall_exit_getrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rlim = event["rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rlim,))

    def handle_compat_syscall_exit_sendfile(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        out_fd = event["out_fd"]
        in_fd = event["in_fd"]
        offset = event["offset"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, out_fd = %s, in_fd = %s, offset = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, out_fd, in_fd, offset, count,))

    def handle_compat_syscall_exit_getcwd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_compat_syscall_exit_chown16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, filename = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, filename, user, group,))

    def handle_compat_syscall_exit_rt_sigsuspend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_rt_sigqueueinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_rt_sigtimedwait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        uthese = event["uthese"]
        uinfo = event["uinfo"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, uthese = %s, uinfo = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, uthese, uinfo,))

    def handle_compat_syscall_exit_rt_sigpending(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        set = event["set"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, set = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, set,))

    def handle_compat_syscall_exit_rt_sigprocmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        oset = event["oset"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, oset = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, oset,))

    def handle_compat_syscall_exit_rt_sigaction(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        oact = event["oact"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, oact = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, oact,))

    def handle_compat_syscall_exit_prctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg2 = event["arg2"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg2 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg2,))

    def handle_compat_syscall_exit_getresgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rgid = event["rgid"]
        egid = event["egid"]
        sgid = event["sgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rgid = %s, egid = %s, sgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rgid, egid, sgid,))

    def handle_compat_syscall_exit_setresgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rgid = event["rgid"]
        egid = event["egid"]
        sgid = event["sgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rgid = %s, egid = %s, sgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rgid, egid, sgid,))

    def handle_compat_syscall_exit_poll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ufds = event["ufds"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ufds = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ufds,))

    def handle_compat_syscall_exit_getresuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ruid = event["ruid"]
        euid = event["euid"]
        suid = event["suid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ruid = %s, euid = %s, suid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ruid, euid, suid,))

    def handle_compat_syscall_exit_setresuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ruid = event["ruid"]
        euid = event["euid"]
        suid = event["suid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ruid = %s, euid = %s, suid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ruid, euid, suid,))

    def handle_compat_syscall_exit_mremap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_nanosleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rmtp = event["rmtp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rmtp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rmtp,))

    def handle_compat_syscall_exit_sched_rr_get_interval(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        interval = event["interval"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, interval = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, interval,))

    def handle_compat_syscall_exit_sched_get_priority_min(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sched_get_priority_max(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sched_yield(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sched_getscheduler(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sched_setscheduler(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sched_getparam(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        param = event["param"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, param = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, param,))

    def handle_compat_syscall_exit_sched_setparam(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_munlockall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mlockall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_munlock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mlock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sysctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, args,))

    def handle_compat_syscall_exit_fdatasync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getsid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_writev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, vec,))

    def handle_compat_syscall_exit_readv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, vec,))

    def handle_compat_syscall_exit_msync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_flock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_select(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        inp = event["inp"]
        outp = event["outp"]
        exp = event["exp"]
        tvp = event["tvp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, inp = %s, outp = %s, exp = %s, tvp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, inp, outp, exp, tvp,))

    def handle_compat_syscall_exit_getdents(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        dirent = event["dirent"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, dirent = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, dirent,))

    def handle_compat_syscall_exit_llseek(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fd = event["fd"]
        offset_high = event["offset_high"]
        offset_low = event["offset_low"]
        result = event["result"]
        origin = event["origin"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fd = %s, offset_high = %s, offset_low = %s, result = %s, origin = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fd, offset_high, offset_low, result, origin,))

    def handle_compat_syscall_exit_setfsgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        gid = event["gid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, gid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, gid,))

    def handle_compat_syscall_exit_setfsuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        uid = event["uid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, uid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, uid,))

    def handle_compat_syscall_exit_personality(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sysfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_bdflush(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        func = event["func"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, func = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, func, data,))

    def handle_compat_syscall_exit_fchdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getpgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_quotactl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        addr = event["addr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, addr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, addr,))

    def handle_compat_syscall_exit_delete_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_init_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sigprocmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        how = event["how"]
        nset = event["nset"]
        oset = event["oset"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, how = %s, nset = %s, oset = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, how, nset, oset,))

    def handle_compat_syscall_exit_mprotect(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_adjtimex(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        txc_p = event["txc_p"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, txc_p = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, txc_p,))

    def handle_compat_syscall_exit_newuname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, name,))

    def handle_compat_syscall_exit_setdomainname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_clone(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fsync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_ipc(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        call = event["call"]
        first = event["first"]
        second = event["second"]
        third = event["third"]
        ptr = event["ptr"]
        fifth = event["fifth"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, call = %s, first = %s, second = %s, third = %s, ptr = %s, fifth = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, call, first, second, third, ptr, fifth,))

    def handle_compat_syscall_exit_sysinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        info = event["info"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, info = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, info,))

    def handle_compat_syscall_exit_swapoff(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_wait4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        stat_addr = event["stat_addr"]
        ru = event["ru"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, stat_addr = %s, ru = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, stat_addr, ru,))

    def handle_compat_syscall_exit_vhangup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_uname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, name,))

    def handle_compat_syscall_exit_newfstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, statbuf,))

    def handle_compat_syscall_exit_newlstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, statbuf,))

    def handle_compat_syscall_exit_newstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, statbuf,))

    def handle_compat_syscall_exit_getitimer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, value,))

    def handle_compat_syscall_exit_setitimer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ovalue = event["ovalue"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ovalue = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ovalue,))

    def handle_compat_syscall_exit_syslog(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_compat_syscall_exit_socketcall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        call = event["call"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, call = %s, args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, call, args,))

    def handle_compat_syscall_exit_fstatfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_compat_syscall_exit_statfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_compat_syscall_exit_setpriority(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getpriority(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fchown16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fd = event["fd"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fd = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fd, user, group,))

    def handle_compat_syscall_exit_fchmod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_ftruncate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_truncate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_munmap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_old_mmap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg,))

    def handle_compat_syscall_exit_old_readdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fd = event["fd"]
        dirent = event["dirent"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fd = %s, dirent = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fd, dirent, count,))

    def handle_compat_syscall_exit_reboot(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_swapon(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_uselib(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        library = event["library"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, library = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, library,))

    def handle_compat_syscall_exit_readlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_compat_syscall_exit_lstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        filename = event["filename"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, filename = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, filename, statbuf,))

    def handle_compat_syscall_exit_symlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_old_select(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg,))

    def handle_compat_syscall_exit_setgroups16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        gidsetsize = event["gidsetsize"]
        grouplist = event["grouplist"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, gidsetsize = %s, grouplist = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, gidsetsize, grouplist,))

    def handle_compat_syscall_exit_getgroups16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        gidsetsize = event["gidsetsize"]
        grouplist = event["grouplist"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, gidsetsize = %s, grouplist = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, gidsetsize, grouplist,))

    def handle_compat_syscall_exit_settimeofday(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_gettimeofday(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tv = event["tv"]
        tz = event["tz"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tv = %s, tz = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tv, tz,))

    def handle_compat_syscall_exit_getrusage(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ru = event["ru"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ru = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ru,))

    def handle_compat_syscall_exit_old_getrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        resource = event["resource"]
        rlim = event["rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, resource = %s, rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, resource, rlim,))

    def handle_compat_syscall_exit_setrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sethostname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sigpending(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        set = event["set"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, set = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, set,))

    def handle_compat_syscall_exit_setregid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rgid = event["rgid"]
        egid = event["egid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rgid = %s, egid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rgid, egid,))

    def handle_compat_syscall_exit_setreuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ruid = event["ruid"]
        euid = event["euid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ruid = %s, euid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ruid, euid,))

    def handle_compat_syscall_exit_ssetmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        newmask = event["newmask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, newmask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, newmask,))

    def handle_compat_syscall_exit_sgetmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setsid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getpgrp(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getppid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_dup2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_ustat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ubuf = event["ubuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ubuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ubuf,))

    def handle_compat_syscall_exit_chroot(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_umask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_olduname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, name,))

    def handle_compat_syscall_exit_setpgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fcntl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg,))

    def handle_compat_syscall_exit_ioctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg,))

    def handle_compat_syscall_exit_umount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_acct(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getegid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_geteuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_signal(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        sig = event["sig"]
        handler = event["handler"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, sig = %s, handler = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, sig, handler,))

    def handle_compat_syscall_exit_getgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        gid = event["gid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, gid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, gid,))

    def handle_compat_syscall_exit_brk(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_times(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tbuf = event["tbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tbuf,))

    def handle_compat_syscall_exit_pipe(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fildes = event["fildes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fildes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fildes,))

    def handle_compat_syscall_exit_dup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_rmdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mkdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_rename(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_kill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_sync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_nice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        increment = event["increment"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, increment = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, increment,))

    def handle_compat_syscall_exit_access(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_utime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_pause(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_fstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fd = event["fd"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fd = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fd, statbuf,))

    def handle_compat_syscall_exit_alarm(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_ptrace(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        addr = event["addr"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, addr = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, addr, data,))

    def handle_compat_syscall_exit_stime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tptr = event["tptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tptr,))

    def handle_compat_syscall_exit_getuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_setuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        uid = event["uid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, uid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, uid,))

    def handle_compat_syscall_exit_oldumount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, name,))

    def handle_compat_syscall_exit_mount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_getpid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_lseek(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_stat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        filename = event["filename"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, filename = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, filename, statbuf,))

    def handle_compat_syscall_exit_lchown16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, filename = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, filename, user, group,))

    def handle_compat_syscall_exit_chmod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_mknod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_time(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tloc = event["tloc"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tloc = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tloc,))

    def handle_compat_syscall_exit_chdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_execve(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_unlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_link(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_creat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_waitpid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        pid = event["pid"]
        stat_addr = event["stat_addr"]
        options = event["options"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, pid = %s, stat_addr = %s, options = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, pid, stat_addr, options,))

    def handle_compat_syscall_exit_close(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_write(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_read(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_compat_syscall_exit_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_exit_restart_syscall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_compat_syscall_entry_setns(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        nstype = event["nstype"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, nstype = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, nstype,))

    def handle_compat_syscall_entry_sendmmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        mmsg = event["mmsg"]
        vlen = event["vlen"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, mmsg = %s, vlen = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, mmsg, vlen, flags,))

    def handle_compat_syscall_entry_syncfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_compat_syscall_entry_clock_adjtime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]
        utx = event["utx"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s, utx = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock, utx,))

    def handle_compat_syscall_entry_prlimit64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        resource = event["resource"]
        new_rlim = event["new_rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, resource = %s, new_rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, resource, new_rlim,))

    def handle_compat_syscall_entry_fanotify_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]
        event_f_flags = event["event_f_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s, event_f_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags, event_f_flags,))

    def handle_compat_syscall_entry_recvmmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vlen = event["vlen"]
        flags = event["flags"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vlen = %s, flags = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vlen, flags, timeout,))

    def handle_compat_syscall_entry_perf_event_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        attr_uptr = event["attr_uptr"]
        pid = event["pid"]
        cpu = event["cpu"]
        group_fd = event["group_fd"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { attr_uptr = %s, pid = %s, cpu = %s, group_fd = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, attr_uptr, pid, cpu, group_fd, flags,))

    def handle_compat_syscall_entry_rt_tgsigqueueinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tgid = event["tgid"]
        pid = event["pid"]
        sig = event["sig"]
        uinfo = event["uinfo"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tgid = %s, pid = %s, sig = %s, uinfo = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tgid, pid, sig, uinfo,))

    def handle_compat_syscall_entry_pwritev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vec = event["vec"]
        vlen = event["vlen"]
        pos_l = event["pos_l"]
        pos_h = event["pos_h"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vec = %s, vlen = %s, pos_l = %s, pos_h = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vec, vlen, pos_l, pos_h,))

    def handle_compat_syscall_entry_preadv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vlen = event["vlen"]
        pos_l = event["pos_l"]
        pos_h = event["pos_h"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vlen = %s, pos_l = %s, pos_h = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vlen, pos_l, pos_h,))

    def handle_compat_syscall_entry_inotify_init1(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags,))

    def handle_compat_syscall_entry_pipe2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags,))

    def handle_compat_syscall_entry_dup3(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldfd = event["oldfd"]
        newfd = event["newfd"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldfd = %s, newfd = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldfd, newfd, flags,))

    def handle_compat_syscall_entry_epoll_create1(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags,))

    def handle_compat_syscall_entry_eventfd2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        count = event["count"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { count = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, count, flags,))

    def handle_compat_syscall_entry_signalfd4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufd = event["ufd"]
        user_mask = event["user_mask"]
        sizemask = event["sizemask"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufd = %s, user_mask = %s, sizemask = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufd, user_mask, sizemask, flags,))

    def handle_compat_syscall_entry_timerfd_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufd = event["ufd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufd,))

    def handle_compat_syscall_entry_timerfd_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufd = event["ufd"]
        flags = event["flags"]
        utmr = event["utmr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufd = %s, flags = %s, utmr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufd, flags, utmr,))

    def handle_compat_syscall_entry_eventfd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, count,))

    def handle_compat_syscall_entry_timerfd_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clockid = event["clockid"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clockid = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clockid, flags,))

    def handle_compat_syscall_entry_signalfd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufd = event["ufd"]
        user_mask = event["user_mask"]
        sizemask = event["sizemask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufd = %s, user_mask = %s, sizemask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufd, user_mask, sizemask,))

    def handle_compat_syscall_entry_utimensat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        utimes = event["utimes"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, utimes = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, utimes, flags,))

    def handle_compat_syscall_entry_epoll_pwait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        epfd = event["epfd"]
        maxevents = event["maxevents"]
        timeout = event["timeout"]
        sigmask = event["sigmask"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { epfd = %s, maxevents = %s, timeout = %s, sigmask = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, epfd, maxevents, timeout, sigmask, sigsetsize,))

    def handle_compat_syscall_entry_getcpu(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tcache = event["tcache"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tcache = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tcache,))

    def handle_compat_syscall_entry_vmsplice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        iov = event["iov"]
        nr_segs = event["nr_segs"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, iov = %s, nr_segs = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, iov, nr_segs, flags,))

    def handle_compat_syscall_entry_tee(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fdin = event["fdin"]
        fdout = event["fdout"]
        len = event["len"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fdin = %s, fdout = %s, len = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fdin, fdout, len, flags,))

    def handle_compat_syscall_entry_splice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd_in = event["fd_in"]
        off_in = event["off_in"]
        fd_out = event["fd_out"]
        off_out = event["off_out"]
        len = event["len"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd_in = %s, off_in = %s, fd_out = %s, off_out = %s, len = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd_in, off_in, fd_out, off_out, len, flags,))

    def handle_compat_syscall_entry_get_robust_list(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_compat_syscall_entry_set_robust_list(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        head = event["head"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { head = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, head, len,))

    def handle_compat_syscall_entry_unshare(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        unshare_flags = event["unshare_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { unshare_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, unshare_flags,))

    def handle_compat_syscall_entry_ppoll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufds = event["ufds"]
        nfds = event["nfds"]
        tsp = event["tsp"]
        sigmask = event["sigmask"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufds = %s, nfds = %s, tsp = %s, sigmask = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufds, nfds, tsp, sigmask, sigsetsize,))

    def handle_compat_syscall_entry_pselect6(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        n = event["n"]
        inp = event["inp"]
        outp = event["outp"]
        exp = event["exp"]
        tsp = event["tsp"]
        sig = event["sig"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { n = %s, inp = %s, outp = %s, exp = %s, tsp = %s, sig = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, n, inp, outp, exp, tsp, sig,))

    def handle_compat_syscall_entry_faccessat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, mode,))

    def handle_compat_syscall_entry_fchmodat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, mode,))

    def handle_compat_syscall_entry_readlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        pathname = event["pathname"]
        bufsiz = event["bufsiz"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, pathname = %s, bufsiz = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, pathname, bufsiz,))

    def handle_compat_syscall_entry_symlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldname = event["oldname"]
        newdfd = event["newdfd"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldname = %s, newdfd = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldname, newdfd, newname,))

    def handle_compat_syscall_entry_linkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        olddfd = event["olddfd"]
        oldname = event["oldname"]
        newdfd = event["newdfd"]
        newname = event["newname"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { olddfd = %s, oldname = %s, newdfd = %s, newname = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, olddfd, oldname, newdfd, newname, flags,))

    def handle_compat_syscall_entry_renameat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        olddfd = event["olddfd"]
        oldname = event["oldname"]
        newdfd = event["newdfd"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { olddfd = %s, oldname = %s, newdfd = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, olddfd, oldname, newdfd, newname,))

    def handle_compat_syscall_entry_unlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        pathname = event["pathname"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, pathname = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, pathname, flag,))

    def handle_compat_syscall_entry_fstatat64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        statbuf = event["statbuf"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, statbuf = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, statbuf, flag,))

    def handle_compat_syscall_entry_futimesat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        utimes = event["utimes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, utimes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, utimes,))

    def handle_compat_syscall_entry_fchownat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, user = %s, group = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, user, group, flag,))

    def handle_compat_syscall_entry_mknodat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        mode = event["mode"]
        dev = event["dev"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, mode = %s, dev = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, mode, dev,))

    def handle_compat_syscall_entry_mkdirat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        pathname = event["pathname"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, pathname = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, pathname, mode,))

    def handle_compat_syscall_entry_openat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        flags = event["flags"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, flags = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, flags, mode,))

    def handle_compat_syscall_entry_inotify_rm_watch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        wd = event["wd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, wd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, wd,))

    def handle_compat_syscall_entry_inotify_add_watch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        pathname = event["pathname"]
        mask = event["mask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, pathname = %s, mask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, pathname, mask,))

    def handle_compat_syscall_entry_inotify_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_ioprio_get(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        who = event["who"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, who = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, who,))

    def handle_compat_syscall_entry_ioprio_set(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        who = event["who"]
        ioprio = event["ioprio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, who = %s, ioprio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, who, ioprio,))

    def handle_compat_syscall_entry_keyctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        option = event["option"]
        arg2 = event["arg2"]
        arg3 = event["arg3"]
        arg4 = event["arg4"]
        arg5 = event["arg5"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { option = %s, arg2 = %s, arg3 = %s, arg4 = %s, arg5 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, option, arg2, arg3, arg4, arg5,))

    def handle_compat_syscall_entry_request_key(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        _type = event["_type"]
        _description = event["_description"]
        _callout_info = event["_callout_info"]
        destringid = event["destringid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { _type = %s, _description = %s, _callout_info = %s, destringid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, _type, _description, _callout_info, destringid,))

    def handle_compat_syscall_entry_add_key(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        _type = event["_type"]
        _description = event["_description"]
        _payload = event["_payload"]
        plen = event["plen"]
        ringid = event["ringid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { _type = %s, _description = %s, _payload = %s, plen = %s, ringid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, _type, _description, _payload, plen, ringid,))

    def handle_compat_syscall_entry_waitid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        upid = event["upid"]
        options = event["options"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, upid = %s, options = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, upid, options,))

    def handle_compat_syscall_entry_kexec_load(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        entry = event["entry"]
        nr_segments = event["nr_segments"]
        segments = event["segments"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { entry = %s, nr_segments = %s, segments = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, entry, nr_segments, segments, flags,))

    def handle_compat_syscall_entry_mq_getsetattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mqdes = event["mqdes"]
        u_mqstat = event["u_mqstat"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mqdes = %s, u_mqstat = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mqdes, u_mqstat,))

    def handle_compat_syscall_entry_mq_notify(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mqdes = event["mqdes"]
        u_notification = event["u_notification"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mqdes = %s, u_notification = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mqdes, u_notification,))

    def handle_compat_syscall_entry_mq_timedreceive(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mqdes = event["mqdes"]
        msg_len = event["msg_len"]
        u_abs_timeout = event["u_abs_timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mqdes = %s, msg_len = %s, u_abs_timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mqdes, msg_len, u_abs_timeout,))

    def handle_compat_syscall_entry_mq_timedsend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mqdes = event["mqdes"]
        u_msg_ptr = event["u_msg_ptr"]
        msg_len = event["msg_len"]
        msg_prio = event["msg_prio"]
        u_abs_timeout = event["u_abs_timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mqdes = %s, u_msg_ptr = %s, msg_len = %s, msg_prio = %s, u_abs_timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout,))

    def handle_compat_syscall_entry_mq_unlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        u_name = event["u_name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { u_name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, u_name,))

    def handle_compat_syscall_entry_mq_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        u_name = event["u_name"]
        oflag = event["oflag"]
        mode = event["mode"]
        u_attr = event["u_attr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { u_name = %s, oflag = %s, mode = %s, u_attr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, u_name, oflag, mode, u_attr,))

    def handle_compat_syscall_entry_utimes(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        utimes = event["utimes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, utimes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, utimes,))

    def handle_compat_syscall_entry_tgkill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tgid = event["tgid"]
        pid = event["pid"]
        sig = event["sig"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tgid = %s, pid = %s, sig = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tgid, pid, sig,))

    def handle_compat_syscall_entry_fstatfs64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        sz = event["sz"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, sz = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, sz, buf,))

    def handle_compat_syscall_entry_statfs64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        sz = event["sz"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, sz = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, sz, buf,))

    def handle_compat_syscall_entry_clock_nanosleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]
        flags = event["flags"]
        rqtp = event["rqtp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s, flags = %s, rqtp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock, flags, rqtp,))

    def handle_compat_syscall_entry_clock_getres(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock,))

    def handle_compat_syscall_entry_clock_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock,))

    def handle_compat_syscall_entry_clock_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]
        tp = event["tp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s, tp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock, tp,))

    def handle_compat_syscall_entry_timer_delete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer_id = event["timer_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer_id,))

    def handle_compat_syscall_entry_timer_getoverrun(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer_id = event["timer_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer_id,))

    def handle_compat_syscall_entry_timer_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer_id = event["timer_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer_id,))

    def handle_compat_syscall_entry_timer_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer_id = event["timer_id"]
        flags = event["flags"]
        new_setting = event["new_setting"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer_id = %s, flags = %s, new_setting = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer_id, flags, new_setting,))

    def handle_compat_syscall_entry_timer_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]
        timer_event_spec = event["timer_event_spec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s, timer_event_spec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock, timer_event_spec,))

    def handle_compat_syscall_entry_set_tid_address(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tidptr = event["tidptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tidptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tidptr,))

    def handle_compat_syscall_entry_remap_file_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        size = event["size"]
        prot = event["prot"]
        pgoff = event["pgoff"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, size = %s, prot = %s, pgoff = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, size, prot, pgoff, flags,))

    def handle_compat_syscall_entry_epoll_wait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        epfd = event["epfd"]
        maxevents = event["maxevents"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { epfd = %s, maxevents = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, epfd, maxevents, timeout,))

    def handle_compat_syscall_entry_epoll_ctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        epfd = event["epfd"]
        op = event["op"]
        fd = event["fd"]
        _event = event["event"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { epfd = %s, op = %s, fd = %s, event = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, epfd, op, fd, _event,))

    def handle_compat_syscall_entry_epoll_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, size,))

    def handle_compat_syscall_entry_exit_group(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        error_code = event["error_code"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { error_code = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, error_code,))

    def handle_compat_syscall_entry_io_cancel(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ctx_id = event["ctx_id"]
        iocb = event["iocb"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ctx_id = %s, iocb = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ctx_id, iocb,))

    def handle_compat_syscall_entry_io_submit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ctx_id = event["ctx_id"]
        nr = event["nr"]
        iocbpp = event["iocbpp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ctx_id = %s, nr = %s, iocbpp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ctx_id, nr, iocbpp,))

    def handle_compat_syscall_entry_io_getevents(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ctx_id = event["ctx_id"]
        min_nr = event["min_nr"]
        nr = event["nr"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ctx_id = %s, min_nr = %s, nr = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ctx_id, min_nr, nr, timeout,))

    def handle_compat_syscall_entry_io_destroy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ctx = event["ctx"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ctx = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ctx,))

    def handle_compat_syscall_entry_io_setup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_events = event["nr_events"]
        ctxp = event["ctxp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_events = %s, ctxp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_events, ctxp,))

    def handle_compat_syscall_entry_sched_getaffinity(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, len,))

    def handle_compat_syscall_entry_sched_setaffinity(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        len = event["len"]
        user_mask_ptr = event["user_mask_ptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, len = %s, user_mask_ptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, len, user_mask_ptr,))

    def handle_compat_syscall_entry_futex(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uaddr = event["uaddr"]
        op = event["op"]
        val = event["val"]
        utime = event["utime"]
        uaddr2 = event["uaddr2"]
        val3 = event["val3"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uaddr = %s, op = %s, val = %s, utime = %s, uaddr2 = %s, val3 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uaddr, op, val, utime, uaddr2, val3,))

    def handle_compat_syscall_entry_sendfile64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        out_fd = event["out_fd"]
        in_fd = event["in_fd"]
        offset = event["offset"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { out_fd = %s, in_fd = %s, offset = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, out_fd, in_fd, offset, count,))

    def handle_compat_syscall_entry_tkill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        sig = event["sig"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, sig = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, sig,))

    def handle_compat_syscall_entry_fremovexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, name,))

    def handle_compat_syscall_entry_lremovexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name,))

    def handle_compat_syscall_entry_removexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name,))

    def handle_compat_syscall_entry_flistxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, size,))

    def handle_compat_syscall_entry_llistxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, size,))

    def handle_compat_syscall_entry_listxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, size,))

    def handle_compat_syscall_entry_fgetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        name = event["name"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, name = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, name, size,))

    def handle_compat_syscall_entry_lgetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name, size,))

    def handle_compat_syscall_entry_getxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name, size,))

    def handle_compat_syscall_entry_fsetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        name = event["name"]
        value = event["value"]
        size = event["size"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, name = %s, value = %s, size = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, name, value, size, flags,))

    def handle_compat_syscall_entry_lsetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]
        value = event["value"]
        size = event["size"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s, value = %s, size = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name, value, size, flags,))

    def handle_compat_syscall_entry_setxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]
        value = event["value"]
        size = event["size"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s, value = %s, size = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name, value, size, flags,))

    def handle_compat_syscall_entry_gettid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_fcntl64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, cmd, arg,))

    def handle_compat_syscall_entry_getdents64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, count,))

    def handle_compat_syscall_entry_madvise(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len_in = event["len_in"]
        behavior = event["behavior"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len_in = %s, behavior = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len_in, behavior,))

    def handle_compat_syscall_entry_mincore(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len,))

    def handle_compat_syscall_entry_pivot_root(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        new_root = event["new_root"]
        put_old = event["put_old"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { new_root = %s, put_old = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, new_root, put_old,))

    def handle_compat_syscall_entry_setfsgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gid = event["gid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gid,))

    def handle_compat_syscall_entry_setfsuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uid = event["uid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uid,))

    def handle_compat_syscall_entry_setgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gid = event["gid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gid,))

    def handle_compat_syscall_entry_setuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uid = event["uid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uid,))

    def handle_compat_syscall_entry_chown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, user, group,))

    def handle_compat_syscall_entry_getresgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_setresgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rgid = event["rgid"]
        egid = event["egid"]
        sgid = event["sgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rgid = %s, egid = %s, sgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rgid, egid, sgid,))

    def handle_compat_syscall_entry_getresuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_setresuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ruid = event["ruid"]
        euid = event["euid"]
        suid = event["suid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ruid = %s, euid = %s, suid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ruid, euid, suid,))

    def handle_compat_syscall_entry_fchown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, user, group,))

    def handle_compat_syscall_entry_setgroups(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gidsetsize = event["gidsetsize"]
        grouplist = event["grouplist"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gidsetsize = %s, grouplist = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gidsetsize, grouplist,))

    def handle_compat_syscall_entry_getgroups(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gidsetsize = event["gidsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gidsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gidsetsize,))

    def handle_compat_syscall_entry_setregid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rgid = event["rgid"]
        egid = event["egid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rgid = %s, egid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rgid, egid,))

    def handle_compat_syscall_entry_setreuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ruid = event["ruid"]
        euid = event["euid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ruid = %s, euid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ruid, euid,))

    def handle_compat_syscall_entry_getegid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_geteuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_getgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_getuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_lchown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, user, group,))

    def handle_compat_syscall_entry_fstat64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, statbuf,))

    def handle_compat_syscall_entry_lstat64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, statbuf,))

    def handle_compat_syscall_entry_stat64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, statbuf,))

    def handle_compat_syscall_entry_mmap_pgoff(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        addr = event["addr"]
        len = event["len"]
        prot = event["prot"]
        flags = event["flags"]
        fd = event["fd"]
        pgoff = event["pgoff"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { addr = %s, len = %s, prot = %s, flags = %s, fd = %s, pgoff = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, addr, len, prot, flags, fd, pgoff,))

    def handle_compat_syscall_entry_getrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        resource = event["resource"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { resource = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, resource,))

    def handle_compat_syscall_entry_sendfile(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        out_fd = event["out_fd"]
        in_fd = event["in_fd"]
        offset = event["offset"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { out_fd = %s, in_fd = %s, offset = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, out_fd, in_fd, offset, count,))

    def handle_compat_syscall_entry_getcwd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, size,))

    def handle_compat_syscall_entry_chown16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, user, group,))

    def handle_compat_syscall_entry_rt_sigsuspend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        unewset = event["unewset"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { unewset = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, unewset, sigsetsize,))

    def handle_compat_syscall_entry_rt_sigqueueinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        sig = event["sig"]
        uinfo = event["uinfo"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, sig = %s, uinfo = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, sig, uinfo,))

    def handle_compat_syscall_entry_rt_sigtimedwait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uts = event["uts"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uts = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uts, sigsetsize,))

    def handle_compat_syscall_entry_rt_sigpending(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, sigsetsize,))

    def handle_compat_syscall_entry_rt_sigprocmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        how = event["how"]
        nset = event["nset"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { how = %s, nset = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, how, nset, sigsetsize,))

    def handle_compat_syscall_entry_rt_sigaction(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        sig = event["sig"]
        act = event["act"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { sig = %s, act = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, sig, act, sigsetsize,))

    def handle_compat_syscall_entry_prctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        option = event["option"]
        arg2 = event["arg2"]
        arg3 = event["arg3"]
        arg4 = event["arg4"]
        arg5 = event["arg5"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { option = %s, arg2 = %s, arg3 = %s, arg4 = %s, arg5 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, option, arg2, arg3, arg4, arg5,))

    def handle_compat_syscall_entry_getresgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rgid = event["rgid"]
        egid = event["egid"]
        sgid = event["sgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rgid = %s, egid = %s, sgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rgid, egid, sgid,))

    def handle_compat_syscall_entry_setresgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rgid = event["rgid"]
        egid = event["egid"]
        sgid = event["sgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rgid = %s, egid = %s, sgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rgid, egid, sgid,))

    def handle_compat_syscall_entry_poll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufds = event["ufds"]
        nfds = event["nfds"]
        timeout_msecs = event["timeout_msecs"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufds = %s, nfds = %s, timeout_msecs = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufds, nfds, timeout_msecs,))

    def handle_compat_syscall_entry_getresuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ruid = event["ruid"]
        euid = event["euid"]
        suid = event["suid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ruid = %s, euid = %s, suid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ruid, euid, suid,))

    def handle_compat_syscall_entry_setresuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ruid = event["ruid"]
        euid = event["euid"]
        suid = event["suid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ruid = %s, euid = %s, suid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ruid, euid, suid,))

    def handle_compat_syscall_entry_mremap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        addr = event["addr"]
        old_len = event["old_len"]
        new_len = event["new_len"]
        flags = event["flags"]
        new_addr = event["new_addr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { addr = %s, old_len = %s, new_len = %s, flags = %s, new_addr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, addr, old_len, new_len, flags, new_addr,))

    def handle_compat_syscall_entry_nanosleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rqtp = event["rqtp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rqtp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rqtp,))

    def handle_compat_syscall_entry_sched_rr_get_interval(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_compat_syscall_entry_sched_get_priority_min(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        policy = event["policy"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { policy = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, policy,))

    def handle_compat_syscall_entry_sched_get_priority_max(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        policy = event["policy"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { policy = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, policy,))

    def handle_compat_syscall_entry_sched_yield(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_sched_getscheduler(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_compat_syscall_entry_sched_setscheduler(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        policy = event["policy"]
        param = event["param"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, policy = %s, param = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, policy, param,))

    def handle_compat_syscall_entry_sched_getparam(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_compat_syscall_entry_sched_setparam(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        param = event["param"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, param = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, param,))

    def handle_compat_syscall_entry_munlockall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_mlockall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags,))

    def handle_compat_syscall_entry_munlock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len,))

    def handle_compat_syscall_entry_mlock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len,))

    def handle_compat_syscall_entry_sysctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, args,))

    def handle_compat_syscall_entry_fdatasync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_compat_syscall_entry_getsid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_compat_syscall_entry_writev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vec = event["vec"]
        vlen = event["vlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vec = %s, vlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vec, vlen,))

    def handle_compat_syscall_entry_readv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vec = event["vec"]
        vlen = event["vlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vec = %s, vlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vec, vlen,))

    def handle_compat_syscall_entry_msync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len, flags,))

    def handle_compat_syscall_entry_flock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        cmd = event["cmd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, cmd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, cmd,))

    def handle_compat_syscall_entry_select(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        n = event["n"]
        inp = event["inp"]
        outp = event["outp"]
        exp = event["exp"]
        tvp = event["tvp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { n = %s, inp = %s, outp = %s, exp = %s, tvp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, n, inp, outp, exp, tvp,))

    def handle_compat_syscall_entry_getdents(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, count,))

    def handle_compat_syscall_entry_llseek(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        offset_high = event["offset_high"]
        offset_low = event["offset_low"]
        result = event["result"]
        origin = event["origin"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, offset_high = %s, offset_low = %s, result = %s, origin = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, offset_high, offset_low, result, origin,))

    def handle_compat_syscall_entry_setfsgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gid = event["gid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gid,))

    def handle_compat_syscall_entry_setfsuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uid = event["uid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uid,))

    def handle_compat_syscall_entry_personality(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        personality = event["personality"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { personality = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, personality,))

    def handle_compat_syscall_entry_sysfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        option = event["option"]
        arg1 = event["arg1"]
        arg2 = event["arg2"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { option = %s, arg1 = %s, arg2 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, option, arg1, arg2,))

    def handle_compat_syscall_entry_bdflush(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        func = event["func"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { func = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, func, data,))

    def handle_compat_syscall_entry_fchdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_compat_syscall_entry_getpgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_compat_syscall_entry_quotactl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        cmd = event["cmd"]
        special = event["special"]
        id = event["id"]
        addr = event["addr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { cmd = %s, special = %s, id = %s, addr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, cmd, special, id, addr,))

    def handle_compat_syscall_entry_delete_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name_user = event["name_user"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name_user = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name_user, flags,))

    def handle_compat_syscall_entry_init_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        umod = event["umod"]
        len = event["len"]
        uargs = event["uargs"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { umod = %s, len = %s, uargs = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, umod, len, uargs,))

    def handle_compat_syscall_entry_sigprocmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        how = event["how"]
        nset = event["nset"]
        oset = event["oset"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { how = %s, nset = %s, oset = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, how, nset, oset,))

    def handle_compat_syscall_entry_mprotect(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]
        prot = event["prot"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s, prot = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len, prot,))

    def handle_compat_syscall_entry_adjtimex(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        txc_p = event["txc_p"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { txc_p = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, txc_p,))

    def handle_compat_syscall_entry_newuname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_setdomainname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, len,))

    def handle_compat_syscall_entry_clone(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clone_flags = event["clone_flags"]
        newsp = event["newsp"]
        parent_tid = event["parent_tid"]
        child_tid = event["child_tid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clone_flags = %s, newsp = %s, parent_tid = %s, child_tid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clone_flags, newsp, parent_tid, child_tid,))

    def handle_compat_syscall_entry_fsync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_compat_syscall_entry_ipc(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        call = event["call"]
        first = event["first"]
        second = event["second"]
        third = event["third"]
        ptr = event["ptr"]
        fifth = event["fifth"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { call = %s, first = %s, second = %s, third = %s, ptr = %s, fifth = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, call, first, second, third, ptr, fifth,))

    def handle_compat_syscall_entry_sysinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_swapoff(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        specialfile = event["specialfile"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { specialfile = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, specialfile,))

    def handle_compat_syscall_entry_wait4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        upid = event["upid"]
        options = event["options"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { upid = %s, options = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, upid, options,))

    def handle_compat_syscall_entry_vhangup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_uname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_compat_syscall_entry_newfstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_compat_syscall_entry_newlstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename,))

    def handle_compat_syscall_entry_newstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename,))

    def handle_compat_syscall_entry_getitimer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which,))

    def handle_compat_syscall_entry_setitimer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, value,))

    def handle_compat_syscall_entry_syslog(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        type = event["type"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { type = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, type, len,))

    def handle_compat_syscall_entry_socketcall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        call = event["call"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { call = %s, args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, call, args,))

    def handle_compat_syscall_entry_fstatfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_compat_syscall_entry_statfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname,))

    def handle_compat_syscall_entry_setpriority(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        who = event["who"]
        niceval = event["niceval"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, who = %s, niceval = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, who, niceval,))

    def handle_compat_syscall_entry_getpriority(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        who = event["who"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, who = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, who,))

    def handle_compat_syscall_entry_fchown16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, user, group,))

    def handle_compat_syscall_entry_fchmod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, mode,))

    def handle_compat_syscall_entry_ftruncate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        length = event["length"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, length = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, length,))

    def handle_compat_syscall_entry_truncate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        path = event["path"]
        length = event["length"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { path = %s, length = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, path, length,))

    def handle_compat_syscall_entry_munmap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        addr = event["addr"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { addr = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, addr, len,))

    def handle_compat_syscall_entry_old_mmap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, arg,))

    def handle_compat_syscall_entry_old_readdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        dirent = event["dirent"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, dirent = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, dirent, count,))

    def handle_compat_syscall_entry_reboot(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        magic1 = event["magic1"]
        magic2 = event["magic2"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { magic1 = %s, magic2 = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, magic1, magic2, cmd, arg,))

    def handle_compat_syscall_entry_swapon(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        specialfile = event["specialfile"]
        swap_flags = event["swap_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { specialfile = %s, swap_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, specialfile, swap_flags,))

    def handle_compat_syscall_entry_uselib(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        library = event["library"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { library = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, library,))

    def handle_compat_syscall_entry_readlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        path = event["path"]
        bufsiz = event["bufsiz"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { path = %s, bufsiz = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, path, bufsiz,))

    def handle_compat_syscall_entry_lstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, statbuf,))

    def handle_compat_syscall_entry_symlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldname = event["oldname"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldname = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldname, newname,))

    def handle_compat_syscall_entry_old_select(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, arg,))

    def handle_compat_syscall_entry_setgroups16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gidsetsize = event["gidsetsize"]
        grouplist = event["grouplist"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gidsetsize = %s, grouplist = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gidsetsize, grouplist,))

    def handle_compat_syscall_entry_getgroups16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gidsetsize = event["gidsetsize"]
        grouplist = event["grouplist"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gidsetsize = %s, grouplist = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gidsetsize, grouplist,))

    def handle_compat_syscall_entry_settimeofday(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tv = event["tv"]
        tz = event["tz"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tv = %s, tz = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tv, tz,))

    def handle_compat_syscall_entry_gettimeofday(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_getrusage(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        who = event["who"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { who = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, who,))

    def handle_compat_syscall_entry_old_getrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        resource = event["resource"]
        rlim = event["rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { resource = %s, rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, resource, rlim,))

    def handle_compat_syscall_entry_setrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        resource = event["resource"]
        rlim = event["rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { resource = %s, rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, resource, rlim,))

    def handle_compat_syscall_entry_sethostname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, len,))

    def handle_compat_syscall_entry_sigpending(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        set = event["set"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { set = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, set,))

    def handle_compat_syscall_entry_setregid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rgid = event["rgid"]
        egid = event["egid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rgid = %s, egid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rgid, egid,))

    def handle_compat_syscall_entry_setreuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ruid = event["ruid"]
        euid = event["euid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ruid = %s, euid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ruid, euid,))

    def handle_compat_syscall_entry_ssetmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        newmask = event["newmask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { newmask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, newmask,))

    def handle_compat_syscall_entry_sgetmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_setsid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_getpgrp(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_getppid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_dup2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldfd = event["oldfd"]
        newfd = event["newfd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldfd = %s, newfd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldfd, newfd,))

    def handle_compat_syscall_entry_ustat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev,))

    def handle_compat_syscall_entry_chroot(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename,))

    def handle_compat_syscall_entry_umask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mask = event["mask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mask,))

    def handle_compat_syscall_entry_olduname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_compat_syscall_entry_setpgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        pgid = event["pgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, pgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, pgid,))

    def handle_compat_syscall_entry_fcntl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, cmd, arg,))

    def handle_compat_syscall_entry_ioctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, cmd, arg,))

    def handle_compat_syscall_entry_umount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, flags,))

    def handle_compat_syscall_entry_acct(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_compat_syscall_entry_getegid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_geteuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_signal(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        sig = event["sig"]
        handler = event["handler"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { sig = %s, handler = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, sig, handler,))

    def handle_compat_syscall_entry_getgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_setgid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gid = event["gid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gid,))

    def handle_compat_syscall_entry_brk(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        brk = event["brk"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { brk = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, brk,))

    def handle_compat_syscall_entry_times(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_pipe(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_dup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fildes = event["fildes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fildes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fildes,))

    def handle_compat_syscall_entry_rmdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname,))

    def handle_compat_syscall_entry_mkdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, mode,))

    def handle_compat_syscall_entry_rename(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldname = event["oldname"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldname = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldname, newname,))

    def handle_compat_syscall_entry_kill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        sig = event["sig"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, sig = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, sig,))

    def handle_compat_syscall_entry_sync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_nice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        increment = event["increment"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { increment = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, increment,))

    def handle_compat_syscall_entry_access(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, mode,))

    def handle_compat_syscall_entry_utime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        times = event["times"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, times = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, times,))

    def handle_compat_syscall_entry_pause(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_fstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, statbuf,))

    def handle_compat_syscall_entry_alarm(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        seconds = event["seconds"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { seconds = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, seconds,))

    def handle_compat_syscall_entry_ptrace(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        request = event["request"]
        pid = event["pid"]
        addr = event["addr"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { request = %s, pid = %s, addr = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, request, pid, addr, data,))

    def handle_compat_syscall_entry_stime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tptr = event["tptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tptr,))

    def handle_compat_syscall_entry_getuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_setuid16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uid = event["uid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uid,))

    def handle_compat_syscall_entry_oldumount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_compat_syscall_entry_mount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev_name = event["dev_name"]
        dir_name = event["dir_name"]
        type = event["type"]
        flags = event["flags"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev_name = %s, dir_name = %s, type = %s, flags = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev_name, dir_name, type, flags, data,))

    def handle_compat_syscall_entry_getpid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_lseek(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        offset = event["offset"]
        origin = event["origin"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, offset = %s, origin = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, offset, origin,))

    def handle_compat_syscall_entry_stat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, statbuf,))

    def handle_compat_syscall_entry_lchown16(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, user, group,))

    def handle_compat_syscall_entry_chmod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, mode,))

    def handle_compat_syscall_entry_mknod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        mode = event["mode"]
        dev = event["dev"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, mode = %s, dev = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, mode, dev,))

    def handle_compat_syscall_entry_time(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_compat_syscall_entry_chdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename,))

    def handle_compat_syscall_entry_execve(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        argv = event["argv"]
        envp = event["envp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, argv = %s, envp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, argv, envp,))

    def handle_compat_syscall_entry_unlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname,))

    def handle_compat_syscall_entry_link(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldname = event["oldname"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldname = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldname, newname,))

    def handle_compat_syscall_entry_creat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, mode,))

    def handle_compat_syscall_entry_waitpid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        stat_addr = event["stat_addr"]
        options = event["options"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, stat_addr = %s, options = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, stat_addr, options,))

    def handle_compat_syscall_entry_close(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_compat_syscall_entry_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        flags = event["flags"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, flags = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, flags, mode,))

    def handle_compat_syscall_entry_write(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        buf = event["buf"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, buf = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, buf, count,))

    def handle_compat_syscall_entry_read(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, count,))

    def handle_compat_syscall_entry_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        error_code = event["error_code"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { error_code = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, error_code,))

    def handle_compat_syscall_entry_restart_syscall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_exit_finit_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_process_vm_writev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_process_vm_readv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        lvec = event["lvec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, lvec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, lvec,))

    def handle_syscall_exit_getcpu(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        cpup = event["cpup"]
        nodep = event["nodep"]
        tcache = event["tcache"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, cpup = %s, nodep = %s, tcache = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, cpup, nodep, tcache,))

    def handle_syscall_exit_setns(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sendmmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_syncfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_clock_adjtime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        utx = event["utx"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, utx = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, utx,))

    def handle_syscall_exit_open_by_handle_at(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_name_to_handle_at(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        handle = event["handle"]
        mnt_id = event["mnt_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, handle = %s, mnt_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, handle, mnt_id,))

    def handle_syscall_exit_prlimit64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        old_rlim = event["old_rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, old_rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, old_rlim,))

    def handle_syscall_exit_fanotify_mark(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fanotify_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_recvmmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        mmsg = event["mmsg"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, mmsg = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, mmsg, timeout,))

    def handle_syscall_exit_perf_event_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_rt_tgsigqueueinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_pwritev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_preadv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, vec,))

    def handle_syscall_exit_inotify_init1(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_pipe2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fildes = event["fildes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fildes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fildes,))

    def handle_syscall_exit_dup3(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_epoll_create1(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_eventfd2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_signalfd4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_accept4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        upeer_sockaddr = event["upeer_sockaddr"]
        upeer_addrlen = event["upeer_addrlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, upeer_sockaddr = %s, upeer_addrlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, upeer_sockaddr, upeer_addrlen,))

    def handle_syscall_exit_timerfd_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        otmr = event["otmr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, otmr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, otmr,))

    def handle_syscall_exit_timerfd_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        otmr = event["otmr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, otmr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, otmr,))

    def handle_syscall_exit_fallocate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_eventfd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_timerfd_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_signalfd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_epoll_pwait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        events = event["events"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, events = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, events,))

    def handle_syscall_exit_utimensat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_move_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        status = event["status"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, status = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, status,))

    def handle_syscall_exit_vmsplice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sync_file_range(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_tee(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_splice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_get_robust_list(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        head_ptr = event["head_ptr"]
        len_ptr = event["len_ptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, head_ptr = %s, len_ptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, head_ptr, len_ptr,))

    def handle_syscall_exit_set_robust_list(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_unshare(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_ppoll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ufds = event["ufds"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ufds = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ufds,))

    def handle_syscall_exit_pselect6(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        inp = event["inp"]
        outp = event["outp"]
        exp = event["exp"]
        tsp = event["tsp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, inp = %s, outp = %s, exp = %s, tsp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, inp, outp, exp, tsp,))

    def handle_syscall_exit_faccessat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fchmodat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_readlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_symlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_linkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_renameat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_unlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_newfstatat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, statbuf,))

    def handle_syscall_exit_futimesat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fchownat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mknodat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mkdirat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_openat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_migrate_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_inotify_rm_watch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_inotify_add_watch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_inotify_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_ioprio_get(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_ioprio_set(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_keyctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg2 = event["arg2"]
        arg3 = event["arg3"]
        arg4 = event["arg4"]
        arg5 = event["arg5"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg2 = %s, arg3 = %s, arg4 = %s, arg5 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg2, arg3, arg4, arg5,))

    def handle_syscall_exit_request_key(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_add_key(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_waitid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        infop = event["infop"]
        ru = event["ru"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, infop = %s, ru = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, infop, ru,))

    def handle_syscall_exit_kexec_load(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mq_getsetattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        u_omqstat = event["u_omqstat"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, u_omqstat = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, u_omqstat,))

    def handle_syscall_exit_mq_notify(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mq_timedreceive(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        u_msg_ptr = event["u_msg_ptr"]
        u_msg_prio = event["u_msg_prio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, u_msg_ptr = %s, u_msg_prio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, u_msg_ptr, u_msg_prio,))

    def handle_syscall_exit_mq_timedsend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mq_unlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mq_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_get_mempolicy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        policy = event["policy"]
        nmask = event["nmask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, policy = %s, nmask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, policy, nmask,))

    def handle_syscall_exit_set_mempolicy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mbind(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_utimes(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_tgkill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_epoll_ctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_epoll_wait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        events = event["events"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, events = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, events,))

    def handle_syscall_exit_exit_group(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_clock_nanosleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rmtp = event["rmtp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rmtp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rmtp,))

    def handle_syscall_exit_clock_getres(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tp = event["tp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tp,))

    def handle_syscall_exit_clock_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tp = event["tp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tp,))

    def handle_syscall_exit_clock_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_timer_delete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_timer_getoverrun(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_timer_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        setting = event["setting"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, setting = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, setting,))

    def handle_syscall_exit_timer_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        old_setting = event["old_setting"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, old_setting = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, old_setting,))

    def handle_syscall_exit_timer_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        created_timer_id = event["created_timer_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, created_timer_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, created_timer_id,))

    def handle_syscall_exit_fadvise64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_semtimedop(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, timeout,))

    def handle_syscall_exit_restart_syscall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_set_tid_address(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getdents64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        dirent = event["dirent"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, dirent = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, dirent,))

    def handle_syscall_exit_remap_file_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_epoll_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_lookup_dcookie(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_io_cancel(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        result = event["result"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, result = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, result,))

    def handle_syscall_exit_io_submit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_io_getevents(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        events = event["events"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, events = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, events, timeout,))

    def handle_syscall_exit_io_destroy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_io_setup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sched_getaffinity(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        user_mask_ptr = event["user_mask_ptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, user_mask_ptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, user_mask_ptr,))

    def handle_syscall_exit_sched_setaffinity(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_futex(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        uaddr = event["uaddr"]
        uaddr2 = event["uaddr2"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, uaddr = %s, uaddr2 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, uaddr, uaddr2,))

    def handle_syscall_exit_time(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tloc = event["tloc"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tloc = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tloc,))

    def handle_syscall_exit_tkill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fremovexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_lremovexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_removexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_flistxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        list = event["list"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, list = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, list,))

    def handle_syscall_exit_llistxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        list = event["list"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, list = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, list,))

    def handle_syscall_exit_listxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        list = event["list"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, list = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, list,))

    def handle_syscall_exit_fgetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, value,))

    def handle_syscall_exit_lgetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, value,))

    def handle_syscall_exit_getxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, value,))

    def handle_syscall_exit_fsetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_lsetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_readahead(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_gettid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_quotactl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        addr = event["addr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, addr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, addr,))

    def handle_syscall_exit_delete_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_init_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setdomainname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sethostname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_reboot(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_swapoff(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_swapon(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_umount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_settimeofday(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_acct(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_chroot(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_adjtimex(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        txc_p = event["txc_p"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, txc_p = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, txc_p,))

    def handle_syscall_exit_prctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg2 = event["arg2"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg2 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg2,))

    def handle_syscall_exit_sysctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, args,))

    def handle_syscall_exit_pivot_root(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_vhangup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_munlockall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mlockall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_munlock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mlock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sched_rr_get_interval(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        interval = event["interval"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, interval = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, interval,))

    def handle_syscall_exit_sched_get_priority_min(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sched_get_priority_max(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sched_getscheduler(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sched_setscheduler(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sched_getparam(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        param = event["param"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, param = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, param,))

    def handle_syscall_exit_sched_setparam(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setpriority(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getpriority(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sysfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fstatfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_statfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_ustat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ubuf = event["ubuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ubuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ubuf,))

    def handle_syscall_exit_personality(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mknod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_utime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sigaltstack(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        uoss = event["uoss"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, uoss = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, uoss,))

    def handle_syscall_exit_rt_sigsuspend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_rt_sigqueueinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_rt_sigtimedwait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        uthese = event["uthese"]
        uinfo = event["uinfo"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, uthese = %s, uinfo = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, uthese, uinfo,))

    def handle_syscall_exit_rt_sigpending(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        uset = event["uset"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, uset = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, uset,))

    def handle_syscall_exit_getsid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setfsgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setfsuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getpgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getresgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rgidp = event["rgidp"]
        egidp = event["egidp"]
        sgidp = event["sgidp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rgidp = %s, egidp = %s, sgidp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rgidp, egidp, sgidp,))

    def handle_syscall_exit_setresgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getresuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ruidp = event["ruidp"]
        euidp = event["euidp"]
        suidp = event["suidp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ruidp = %s, euidp = %s, suidp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ruidp, euidp, suidp,))

    def handle_syscall_exit_setresuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setgroups(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getgroups(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        grouplist = event["grouplist"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, grouplist = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, grouplist,))

    def handle_syscall_exit_setregid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setreuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setsid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getpgrp(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getppid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setpgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getegid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_geteuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_syslog(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_getuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_ptrace(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        addr = event["addr"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, addr = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, addr, data,))

    def handle_syscall_exit_times(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tbuf = event["tbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tbuf,))

    def handle_syscall_exit_sysinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        info = event["info"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, info = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, info,))

    def handle_syscall_exit_getrusage(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ru = event["ru"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ru = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ru,))

    def handle_syscall_exit_getrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rlim = event["rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rlim,))

    def handle_syscall_exit_gettimeofday(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        tv = event["tv"]
        tz = event["tz"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, tv = %s, tz = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, tv, tz,))

    def handle_syscall_exit_umask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_lchown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fchown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_chown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fchmod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_chmod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_readlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_symlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_unlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_link(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_creat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_rmdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mkdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_rename(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fchdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_chdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getcwd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_getdents(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        dirent = event["dirent"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, dirent = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, dirent,))

    def handle_syscall_exit_ftruncate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_truncate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fdatasync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fsync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_flock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_fcntl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg,))

    def handle_syscall_exit_msgctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_msgrcv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        msgp = event["msgp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, msgp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, msgp,))

    def handle_syscall_exit_msgsnd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_msgget(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_shmdt(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_semctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg,))

    def handle_syscall_exit_semop(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_semget(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_newuname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, name,))

    def handle_syscall_exit_kill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_wait4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        stat_addr = event["stat_addr"]
        ru = event["ru"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, stat_addr = %s, ru = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, stat_addr, ru,))

    def handle_syscall_exit_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_execve(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_clone(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getsockopt(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        optval = event["optval"]
        optlen = event["optlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, optval = %s, optlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, optval, optlen,))

    def handle_syscall_exit_setsockopt(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_socketpair(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        usockvec = event["usockvec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, usockvec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, usockvec,))

    def handle_syscall_exit_getpeername(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        usockaddr = event["usockaddr"]
        usockaddr_len = event["usockaddr_len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, usockaddr = %s, usockaddr_len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, usockaddr, usockaddr_len,))

    def handle_syscall_exit_getsockname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        usockaddr = event["usockaddr"]
        usockaddr_len = event["usockaddr_len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, usockaddr = %s, usockaddr_len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, usockaddr, usockaddr_len,))

    def handle_syscall_exit_listen(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_bind(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_shutdown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_recvmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        msg = event["msg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, msg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, msg,))

    def handle_syscall_exit_sendmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_recvfrom(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ubuf = event["ubuf"]
        addr = event["addr"]
        addr_len = event["addr_len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ubuf = %s, addr = %s, addr_len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ubuf, addr, addr_len,))

    def handle_syscall_exit_sendto(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_accept(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        upeer_addrlen = event["upeer_addrlen"]
        family = event["family"]
        sport = event["sport"]
        _v4addr_length = event["_v4addr_length"]
        v4addr = event["v4addr"]
        _v6addr_length = event["_v6addr_length"]
        v6addr = event["v6addr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, upeer_addrlen = %s, family = %s, sport = %s, _v4addr_length = %s, v4addr = %s, _v6addr_length = %s, v6addr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, upeer_addrlen, family, sport, _v4addr_length, v4addr, _v6addr_length, v6addr,))

    def handle_syscall_exit_connect(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_socket(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sendfile64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        offset = event["offset"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, offset = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, offset,))

    def handle_syscall_exit_getpid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_setitimer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ovalue = event["ovalue"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ovalue = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ovalue,))

    def handle_syscall_exit_alarm(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_getitimer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, value,))

    def handle_syscall_exit_nanosleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        rmtp = event["rmtp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, rmtp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, rmtp,))

    def handle_syscall_exit_pause(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_dup2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_dup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_shmctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_shmat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_shmget(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_madvise(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mincore(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, vec,))

    def handle_syscall_exit_msync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mremap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_sched_yield(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_select(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        inp = event["inp"]
        outp = event["outp"]
        exp = event["exp"]
        tvp = event["tvp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, inp = %s, outp = %s, exp = %s, tvp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, inp, outp, exp, tvp,))

    def handle_syscall_exit_pipe(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        fildes = event["fildes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, fildes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, fildes,))

    def handle_syscall_exit_access(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_writev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, vec,))

    def handle_syscall_exit_readv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, vec,))

    def handle_syscall_exit_pwrite64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_pread64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_exit_ioctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, arg,))

    def handle_syscall_exit_rt_sigprocmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        oset = event["oset"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, oset = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, oset,))

    def handle_syscall_exit_rt_sigaction(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        oact = event["oact"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, oact = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, oact,))

    def handle_syscall_exit_brk(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_munmap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mprotect(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_mmap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_lseek(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_poll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        ufds = event["ufds"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, ufds = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, ufds,))

    def handle_syscall_exit_newlstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, statbuf,))

    def handle_syscall_exit_newfstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, statbuf,))

    def handle_syscall_exit_newstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        statbuf = event["statbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, statbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, statbuf,))

    def handle_syscall_exit_close(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_write(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_syscall_exit_read(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret, buf,))

    def handle_syscall_entry_finit_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        uargs = event["uargs"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, uargs = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, uargs, flags,))

    def handle_syscall_entry_process_vm_writev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        lvec = event["lvec"]
        liovcnt = event["liovcnt"]
        rvec = event["rvec"]
        riovcnt = event["riovcnt"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, lvec = %s, liovcnt = %s, rvec = %s, riovcnt = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, lvec, liovcnt, rvec, riovcnt, flags,))

    def handle_syscall_entry_process_vm_readv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        liovcnt = event["liovcnt"]
        rvec = event["rvec"]
        riovcnt = event["riovcnt"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, liovcnt = %s, rvec = %s, riovcnt = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, liovcnt, rvec, riovcnt, flags,))

    def handle_syscall_entry_getcpu(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tcache = event["tcache"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tcache = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tcache,))

    def handle_syscall_entry_setns(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        nstype = event["nstype"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, nstype = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, nstype,))

    def handle_syscall_entry_sendmmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        mmsg = event["mmsg"]
        vlen = event["vlen"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, mmsg = %s, vlen = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, mmsg, vlen, flags,))

    def handle_syscall_entry_syncfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_syscall_entry_clock_adjtime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]
        utx = event["utx"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s, utx = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock, utx,))

    def handle_syscall_entry_open_by_handle_at(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mountdirfd = event["mountdirfd"]
        handle = event["handle"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mountdirfd = %s, handle = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mountdirfd, handle, flags,))

    def handle_syscall_entry_name_to_handle_at(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        name = event["name"]
        handle = event["handle"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, name = %s, handle = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, name, handle, flag,))

    def handle_syscall_entry_prlimit64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        resource = event["resource"]
        new_rlim = event["new_rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, resource = %s, new_rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, resource, new_rlim,))

    def handle_syscall_entry_fanotify_mark(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fanotify_fd = event["fanotify_fd"]
        flags = event["flags"]
        mask = event["mask"]
        dfd = event["dfd"]
        pathname = event["pathname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fanotify_fd = %s, flags = %s, mask = %s, dfd = %s, pathname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fanotify_fd, flags, mask, dfd, pathname,))

    def handle_syscall_entry_fanotify_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]
        event_f_flags = event["event_f_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s, event_f_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags, event_f_flags,))

    def handle_syscall_entry_recvmmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vlen = event["vlen"]
        flags = event["flags"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vlen = %s, flags = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vlen, flags, timeout,))

    def handle_syscall_entry_perf_event_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        attr_uptr = event["attr_uptr"]
        pid = event["pid"]
        cpu = event["cpu"]
        group_fd = event["group_fd"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { attr_uptr = %s, pid = %s, cpu = %s, group_fd = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, attr_uptr, pid, cpu, group_fd, flags,))

    def handle_syscall_entry_rt_tgsigqueueinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tgid = event["tgid"]
        pid = event["pid"]
        sig = event["sig"]
        uinfo = event["uinfo"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tgid = %s, pid = %s, sig = %s, uinfo = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tgid, pid, sig, uinfo,))

    def handle_syscall_entry_pwritev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vec = event["vec"]
        vlen = event["vlen"]
        pos_l = event["pos_l"]
        pos_h = event["pos_h"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vec = %s, vlen = %s, pos_l = %s, pos_h = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vec, vlen, pos_l, pos_h,))

    def handle_syscall_entry_preadv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vlen = event["vlen"]
        pos_l = event["pos_l"]
        pos_h = event["pos_h"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vlen = %s, pos_l = %s, pos_h = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vlen, pos_l, pos_h,))

    def handle_syscall_entry_inotify_init1(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags,))

    def handle_syscall_entry_pipe2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags,))

    def handle_syscall_entry_dup3(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldfd = event["oldfd"]
        newfd = event["newfd"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldfd = %s, newfd = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldfd, newfd, flags,))

    def handle_syscall_entry_epoll_create1(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags,))

    def handle_syscall_entry_eventfd2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        count = event["count"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { count = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, count, flags,))

    def handle_syscall_entry_signalfd4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufd = event["ufd"]
        user_mask = event["user_mask"]
        sizemask = event["sizemask"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufd = %s, user_mask = %s, sizemask = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufd, user_mask, sizemask, flags,))

    def handle_syscall_entry_accept4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        upeer_addrlen = event["upeer_addrlen"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, upeer_addrlen = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, upeer_addrlen, flags,))

    def handle_syscall_entry_timerfd_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufd = event["ufd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufd,))

    def handle_syscall_entry_timerfd_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufd = event["ufd"]
        flags = event["flags"]
        utmr = event["utmr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufd = %s, flags = %s, utmr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufd, flags, utmr,))

    def handle_syscall_entry_fallocate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        mode = event["mode"]
        offset = event["offset"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, mode = %s, offset = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, mode, offset, len,))

    def handle_syscall_entry_eventfd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, count,))

    def handle_syscall_entry_timerfd_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clockid = event["clockid"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clockid = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clockid, flags,))

    def handle_syscall_entry_signalfd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufd = event["ufd"]
        user_mask = event["user_mask"]
        sizemask = event["sizemask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufd = %s, user_mask = %s, sizemask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufd, user_mask, sizemask,))

    def handle_syscall_entry_epoll_pwait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        epfd = event["epfd"]
        maxevents = event["maxevents"]
        timeout = event["timeout"]
        sigmask = event["sigmask"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { epfd = %s, maxevents = %s, timeout = %s, sigmask = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, epfd, maxevents, timeout, sigmask, sigsetsize,))

    def handle_syscall_entry_utimensat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        utimes = event["utimes"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, utimes = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, utimes, flags,))

    def handle_syscall_entry_move_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        nr_pages = event["nr_pages"]
        pages = event["pages"]
        nodes = event["nodes"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, nr_pages = %s, pages = %s, nodes = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, nr_pages, pages, nodes, flags,))

    def handle_syscall_entry_vmsplice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        iov = event["iov"]
        nr_segs = event["nr_segs"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, iov = %s, nr_segs = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, iov, nr_segs, flags,))

    def handle_syscall_entry_sync_file_range(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        offset = event["offset"]
        nbytes = event["nbytes"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, offset = %s, nbytes = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, offset, nbytes, flags,))

    def handle_syscall_entry_tee(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fdin = event["fdin"]
        fdout = event["fdout"]
        len = event["len"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fdin = %s, fdout = %s, len = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fdin, fdout, len, flags,))

    def handle_syscall_entry_splice(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd_in = event["fd_in"]
        off_in = event["off_in"]
        fd_out = event["fd_out"]
        off_out = event["off_out"]
        len = event["len"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd_in = %s, off_in = %s, fd_out = %s, off_out = %s, len = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd_in, off_in, fd_out, off_out, len, flags,))

    def handle_syscall_entry_get_robust_list(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_syscall_entry_set_robust_list(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        head = event["head"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { head = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, head, len,))

    def handle_syscall_entry_unshare(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        unshare_flags = event["unshare_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { unshare_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, unshare_flags,))

    def handle_syscall_entry_ppoll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufds = event["ufds"]
        nfds = event["nfds"]
        tsp = event["tsp"]
        sigmask = event["sigmask"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufds = %s, nfds = %s, tsp = %s, sigmask = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufds, nfds, tsp, sigmask, sigsetsize,))

    def handle_syscall_entry_pselect6(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        n = event["n"]
        inp = event["inp"]
        outp = event["outp"]
        exp = event["exp"]
        tsp = event["tsp"]
        sig = event["sig"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { n = %s, inp = %s, outp = %s, exp = %s, tsp = %s, sig = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, n, inp, outp, exp, tsp, sig,))

    def handle_syscall_entry_faccessat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, mode,))

    def handle_syscall_entry_fchmodat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, mode,))

    def handle_syscall_entry_readlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        pathname = event["pathname"]
        bufsiz = event["bufsiz"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, pathname = %s, bufsiz = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, pathname, bufsiz,))

    def handle_syscall_entry_symlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldname = event["oldname"]
        newdfd = event["newdfd"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldname = %s, newdfd = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldname, newdfd, newname,))

    def handle_syscall_entry_linkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        olddfd = event["olddfd"]
        oldname = event["oldname"]
        newdfd = event["newdfd"]
        newname = event["newname"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { olddfd = %s, oldname = %s, newdfd = %s, newname = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, olddfd, oldname, newdfd, newname, flags,))

    def handle_syscall_entry_renameat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        olddfd = event["olddfd"]
        oldname = event["oldname"]
        newdfd = event["newdfd"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { olddfd = %s, oldname = %s, newdfd = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, olddfd, oldname, newdfd, newname,))

    def handle_syscall_entry_unlinkat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        pathname = event["pathname"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, pathname = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, pathname, flag,))

    def handle_syscall_entry_newfstatat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, flag,))

    def handle_syscall_entry_futimesat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        utimes = event["utimes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, utimes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, utimes,))

    def handle_syscall_entry_fchownat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, user = %s, group = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, user, group, flag,))

    def handle_syscall_entry_mknodat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        mode = event["mode"]
        dev = event["dev"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, mode = %s, dev = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, mode, dev,))

    def handle_syscall_entry_mkdirat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        pathname = event["pathname"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, pathname = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, pathname, mode,))

    def handle_syscall_entry_openat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dfd = event["dfd"]
        filename = event["filename"]
        flags = event["flags"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dfd = %s, filename = %s, flags = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dfd, filename, flags, mode,))

    def handle_syscall_entry_migrate_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        maxnode = event["maxnode"]
        old_nodes = event["old_nodes"]
        new_nodes = event["new_nodes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, maxnode = %s, old_nodes = %s, new_nodes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, maxnode, old_nodes, new_nodes,))

    def handle_syscall_entry_inotify_rm_watch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        wd = event["wd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, wd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, wd,))

    def handle_syscall_entry_inotify_add_watch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        pathname = event["pathname"]
        mask = event["mask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, pathname = %s, mask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, pathname, mask,))

    def handle_syscall_entry_inotify_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_ioprio_get(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        who = event["who"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, who = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, who,))

    def handle_syscall_entry_ioprio_set(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        who = event["who"]
        ioprio = event["ioprio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, who = %s, ioprio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, who, ioprio,))

    def handle_syscall_entry_keyctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        option = event["option"]
        arg2 = event["arg2"]
        arg3 = event["arg3"]
        arg4 = event["arg4"]
        arg5 = event["arg5"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { option = %s, arg2 = %s, arg3 = %s, arg4 = %s, arg5 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, option, arg2, arg3, arg4, arg5,))

    def handle_syscall_entry_request_key(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        _type = event["_type"]
        _description = event["_description"]
        _callout_info = event["_callout_info"]
        destringid = event["destringid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { _type = %s, _description = %s, _callout_info = %s, destringid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, _type, _description, _callout_info, destringid,))

    def handle_syscall_entry_add_key(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        _type = event["_type"]
        _description = event["_description"]
        _payload = event["_payload"]
        plen = event["plen"]
        ringid = event["ringid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { _type = %s, _description = %s, _payload = %s, plen = %s, ringid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, _type, _description, _payload, plen, ringid,))

    def handle_syscall_entry_waitid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        upid = event["upid"]
        options = event["options"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, upid = %s, options = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, upid, options,))

    def handle_syscall_entry_kexec_load(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        entry = event["entry"]
        nr_segments = event["nr_segments"]
        segments = event["segments"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { entry = %s, nr_segments = %s, segments = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, entry, nr_segments, segments, flags,))

    def handle_syscall_entry_mq_getsetattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mqdes = event["mqdes"]
        u_mqstat = event["u_mqstat"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mqdes = %s, u_mqstat = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mqdes, u_mqstat,))

    def handle_syscall_entry_mq_notify(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mqdes = event["mqdes"]
        u_notification = event["u_notification"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mqdes = %s, u_notification = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mqdes, u_notification,))

    def handle_syscall_entry_mq_timedreceive(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mqdes = event["mqdes"]
        msg_len = event["msg_len"]
        u_abs_timeout = event["u_abs_timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mqdes = %s, msg_len = %s, u_abs_timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mqdes, msg_len, u_abs_timeout,))

    def handle_syscall_entry_mq_timedsend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mqdes = event["mqdes"]
        u_msg_ptr = event["u_msg_ptr"]
        msg_len = event["msg_len"]
        msg_prio = event["msg_prio"]
        u_abs_timeout = event["u_abs_timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mqdes = %s, u_msg_ptr = %s, msg_len = %s, msg_prio = %s, u_abs_timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout,))

    def handle_syscall_entry_mq_unlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        u_name = event["u_name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { u_name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, u_name,))

    def handle_syscall_entry_mq_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        u_name = event["u_name"]
        oflag = event["oflag"]
        mode = event["mode"]
        u_attr = event["u_attr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { u_name = %s, oflag = %s, mode = %s, u_attr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, u_name, oflag, mode, u_attr,))

    def handle_syscall_entry_get_mempolicy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        maxnode = event["maxnode"]
        addr = event["addr"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { maxnode = %s, addr = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, maxnode, addr, flags,))

    def handle_syscall_entry_set_mempolicy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mode = event["mode"]
        nmask = event["nmask"]
        maxnode = event["maxnode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mode = %s, nmask = %s, maxnode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mode, nmask, maxnode,))

    def handle_syscall_entry_mbind(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]
        mode = event["mode"]
        nmask = event["nmask"]
        maxnode = event["maxnode"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s, mode = %s, nmask = %s, maxnode = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len, mode, nmask, maxnode, flags,))

    def handle_syscall_entry_utimes(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        utimes = event["utimes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, utimes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, utimes,))

    def handle_syscall_entry_tgkill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tgid = event["tgid"]
        pid = event["pid"]
        sig = event["sig"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tgid = %s, pid = %s, sig = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tgid, pid, sig,))

    def handle_syscall_entry_epoll_ctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        epfd = event["epfd"]
        op = event["op"]
        fd = event["fd"]
        _event = event["event"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { epfd = %s, op = %s, fd = %s, event = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, epfd, op, fd, _event,))

    def handle_syscall_entry_epoll_wait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        epfd = event["epfd"]
        maxevents = event["maxevents"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { epfd = %s, maxevents = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, epfd, maxevents, timeout,))

    def handle_syscall_entry_exit_group(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        error_code = event["error_code"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { error_code = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, error_code,))

    def handle_syscall_entry_clock_nanosleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]
        flags = event["flags"]
        rqtp = event["rqtp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s, flags = %s, rqtp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock, flags, rqtp,))

    def handle_syscall_entry_clock_getres(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock,))

    def handle_syscall_entry_clock_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock,))

    def handle_syscall_entry_clock_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]
        tp = event["tp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s, tp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock, tp,))

    def handle_syscall_entry_timer_delete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer_id = event["timer_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer_id,))

    def handle_syscall_entry_timer_getoverrun(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer_id = event["timer_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer_id,))

    def handle_syscall_entry_timer_gettime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer_id = event["timer_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer_id,))

    def handle_syscall_entry_timer_settime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer_id = event["timer_id"]
        flags = event["flags"]
        new_setting = event["new_setting"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer_id = %s, flags = %s, new_setting = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer_id, flags, new_setting,))

    def handle_syscall_entry_timer_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which_clock = event["which_clock"]
        timer_event_spec = event["timer_event_spec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which_clock = %s, timer_event_spec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which_clock, timer_event_spec,))

    def handle_syscall_entry_fadvise64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        offset = event["offset"]
        len = event["len"]
        advice = event["advice"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, offset = %s, len = %s, advice = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, offset, len, advice,))

    def handle_syscall_entry_semtimedop(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        semid = event["semid"]
        tsops = event["tsops"]
        nsops = event["nsops"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { semid = %s, tsops = %s, nsops = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, semid, tsops, nsops, timeout,))

    def handle_syscall_entry_restart_syscall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_set_tid_address(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tidptr = event["tidptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tidptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tidptr,))

    def handle_syscall_entry_getdents64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, count,))

    def handle_syscall_entry_remap_file_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        size = event["size"]
        prot = event["prot"]
        pgoff = event["pgoff"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, size = %s, prot = %s, pgoff = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, size, prot, pgoff, flags,))

    def handle_syscall_entry_epoll_create(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, size,))

    def handle_syscall_entry_lookup_dcookie(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        cookie64 = event["cookie64"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { cookie64 = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, cookie64, len,))

    def handle_syscall_entry_io_cancel(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ctx_id = event["ctx_id"]
        iocb = event["iocb"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ctx_id = %s, iocb = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ctx_id, iocb,))

    def handle_syscall_entry_io_submit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ctx_id = event["ctx_id"]
        nr = event["nr"]
        iocbpp = event["iocbpp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ctx_id = %s, nr = %s, iocbpp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ctx_id, nr, iocbpp,))

    def handle_syscall_entry_io_getevents(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ctx_id = event["ctx_id"]
        min_nr = event["min_nr"]
        nr = event["nr"]
        timeout = event["timeout"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ctx_id = %s, min_nr = %s, nr = %s, timeout = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ctx_id, min_nr, nr, timeout,))

    def handle_syscall_entry_io_destroy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ctx = event["ctx"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ctx = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ctx,))

    def handle_syscall_entry_io_setup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_events = event["nr_events"]
        ctxp = event["ctxp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_events = %s, ctxp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_events, ctxp,))

    def handle_syscall_entry_sched_getaffinity(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, len,))

    def handle_syscall_entry_sched_setaffinity(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        len = event["len"]
        user_mask_ptr = event["user_mask_ptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, len = %s, user_mask_ptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, len, user_mask_ptr,))

    def handle_syscall_entry_futex(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uaddr = event["uaddr"]
        op = event["op"]
        val = event["val"]
        utime = event["utime"]
        uaddr2 = event["uaddr2"]
        val3 = event["val3"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uaddr = %s, op = %s, val = %s, utime = %s, uaddr2 = %s, val3 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uaddr, op, val, utime, uaddr2, val3,))

    def handle_syscall_entry_time(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_tkill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        sig = event["sig"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, sig = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, sig,))

    def handle_syscall_entry_fremovexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, name,))

    def handle_syscall_entry_lremovexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name,))

    def handle_syscall_entry_removexattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name,))

    def handle_syscall_entry_flistxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, size,))

    def handle_syscall_entry_llistxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, size,))

    def handle_syscall_entry_listxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, size,))

    def handle_syscall_entry_fgetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        name = event["name"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, name = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, name, size,))

    def handle_syscall_entry_lgetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name, size,))

    def handle_syscall_entry_getxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name, size,))

    def handle_syscall_entry_fsetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        name = event["name"]
        value = event["value"]
        size = event["size"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, name = %s, value = %s, size = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, name, value, size, flags,))

    def handle_syscall_entry_lsetxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]
        value = event["value"]
        size = event["size"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s, value = %s, size = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name, value, size, flags,))

    def handle_syscall_entry_setxattr(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        name = event["name"]
        value = event["value"]
        size = event["size"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, name = %s, value = %s, size = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, name, value, size, flags,))

    def handle_syscall_entry_readahead(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        offset = event["offset"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, offset = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, offset, count,))

    def handle_syscall_entry_gettid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_quotactl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        cmd = event["cmd"]
        special = event["special"]
        id = event["id"]
        addr = event["addr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { cmd = %s, special = %s, id = %s, addr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, cmd, special, id, addr,))

    def handle_syscall_entry_delete_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name_user = event["name_user"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name_user = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name_user, flags,))

    def handle_syscall_entry_init_module(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        umod = event["umod"]
        len = event["len"]
        uargs = event["uargs"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { umod = %s, len = %s, uargs = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, umod, len, uargs,))

    def handle_syscall_entry_setdomainname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, len,))

    def handle_syscall_entry_sethostname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, len,))

    def handle_syscall_entry_reboot(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        magic1 = event["magic1"]
        magic2 = event["magic2"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { magic1 = %s, magic2 = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, magic1, magic2, cmd, arg,))

    def handle_syscall_entry_swapoff(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        specialfile = event["specialfile"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { specialfile = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, specialfile,))

    def handle_syscall_entry_swapon(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        specialfile = event["specialfile"]
        swap_flags = event["swap_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { specialfile = %s, swap_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, specialfile, swap_flags,))

    def handle_syscall_entry_umount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, flags,))

    def handle_syscall_entry_mount(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev_name = event["dev_name"]
        dir_name = event["dir_name"]
        type = event["type"]
        flags = event["flags"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev_name = %s, dir_name = %s, type = %s, flags = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev_name, dir_name, type, flags, data,))

    def handle_syscall_entry_settimeofday(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tv = event["tv"]
        tz = event["tz"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tv = %s, tz = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tv, tz,))

    def handle_syscall_entry_acct(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_syscall_entry_sync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_chroot(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename,))

    def handle_syscall_entry_setrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        resource = event["resource"]
        rlim = event["rlim"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { resource = %s, rlim = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, resource, rlim,))

    def handle_syscall_entry_adjtimex(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        txc_p = event["txc_p"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { txc_p = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, txc_p,))

    def handle_syscall_entry_prctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        option = event["option"]
        arg2 = event["arg2"]
        arg3 = event["arg3"]
        arg4 = event["arg4"]
        arg5 = event["arg5"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { option = %s, arg2 = %s, arg3 = %s, arg4 = %s, arg5 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, option, arg2, arg3, arg4, arg5,))

    def handle_syscall_entry_sysctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, args,))

    def handle_syscall_entry_pivot_root(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        new_root = event["new_root"]
        put_old = event["put_old"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { new_root = %s, put_old = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, new_root, put_old,))

    def handle_syscall_entry_vhangup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_munlockall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_mlockall(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, flags,))

    def handle_syscall_entry_munlock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len,))

    def handle_syscall_entry_mlock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len,))

    def handle_syscall_entry_sched_rr_get_interval(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_syscall_entry_sched_get_priority_min(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        policy = event["policy"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { policy = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, policy,))

    def handle_syscall_entry_sched_get_priority_max(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        policy = event["policy"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { policy = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, policy,))

    def handle_syscall_entry_sched_getscheduler(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_syscall_entry_sched_setscheduler(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        policy = event["policy"]
        param = event["param"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, policy = %s, param = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, policy, param,))

    def handle_syscall_entry_sched_getparam(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_syscall_entry_sched_setparam(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        param = event["param"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, param = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, param,))

    def handle_syscall_entry_setpriority(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        who = event["who"]
        niceval = event["niceval"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, who = %s, niceval = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, who, niceval,))

    def handle_syscall_entry_getpriority(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        who = event["who"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, who = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, who,))

    def handle_syscall_entry_sysfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        option = event["option"]
        arg1 = event["arg1"]
        arg2 = event["arg2"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { option = %s, arg1 = %s, arg2 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, option, arg1, arg2,))

    def handle_syscall_entry_fstatfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_syscall_entry_statfs(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname,))

    def handle_syscall_entry_ustat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev,))

    def handle_syscall_entry_personality(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        personality = event["personality"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { personality = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, personality,))

    def handle_syscall_entry_mknod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        mode = event["mode"]
        dev = event["dev"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, mode = %s, dev = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, mode, dev,))

    def handle_syscall_entry_utime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        times = event["times"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, times = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, times,))

    def handle_syscall_entry_sigaltstack(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uss = event["uss"]
        uoss = event["uoss"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uss = %s, uoss = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uss, uoss,))

    def handle_syscall_entry_rt_sigsuspend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        unewset = event["unewset"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { unewset = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, unewset, sigsetsize,))

    def handle_syscall_entry_rt_sigqueueinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        sig = event["sig"]
        uinfo = event["uinfo"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, sig = %s, uinfo = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, sig, uinfo,))

    def handle_syscall_entry_rt_sigtimedwait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uts = event["uts"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uts = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uts, sigsetsize,))

    def handle_syscall_entry_rt_sigpending(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, sigsetsize,))

    def handle_syscall_entry_getsid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_syscall_entry_setfsgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gid = event["gid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gid,))

    def handle_syscall_entry_setfsuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uid = event["uid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uid,))

    def handle_syscall_entry_getpgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid,))

    def handle_syscall_entry_getresgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_setresgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rgid = event["rgid"]
        egid = event["egid"]
        sgid = event["sgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rgid = %s, egid = %s, sgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rgid, egid, sgid,))

    def handle_syscall_entry_getresuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_setresuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ruid = event["ruid"]
        euid = event["euid"]
        suid = event["suid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ruid = %s, euid = %s, suid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ruid, euid, suid,))

    def handle_syscall_entry_setgroups(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gidsetsize = event["gidsetsize"]
        grouplist = event["grouplist"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gidsetsize = %s, grouplist = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gidsetsize, grouplist,))

    def handle_syscall_entry_getgroups(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gidsetsize = event["gidsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gidsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gidsetsize,))

    def handle_syscall_entry_setregid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rgid = event["rgid"]
        egid = event["egid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rgid = %s, egid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rgid, egid,))

    def handle_syscall_entry_setreuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ruid = event["ruid"]
        euid = event["euid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ruid = %s, euid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ruid, euid,))

    def handle_syscall_entry_setsid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_getpgrp(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_getppid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_setpgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        pgid = event["pgid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, pgid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, pgid,))

    def handle_syscall_entry_getegid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_geteuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_setgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gid = event["gid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gid,))

    def handle_syscall_entry_setuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        uid = event["uid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { uid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, uid,))

    def handle_syscall_entry_getgid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_syslog(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        type = event["type"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { type = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, type, len,))

    def handle_syscall_entry_getuid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_ptrace(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        request = event["request"]
        pid = event["pid"]
        addr = event["addr"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { request = %s, pid = %s, addr = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, request, pid, addr, data,))

    def handle_syscall_entry_times(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_sysinfo(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_getrusage(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        who = event["who"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { who = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, who,))

    def handle_syscall_entry_getrlimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        resource = event["resource"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { resource = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, resource,))

    def handle_syscall_entry_gettimeofday(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_umask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        mask = event["mask"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { mask = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, mask,))

    def handle_syscall_entry_lchown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, user, group,))

    def handle_syscall_entry_fchown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, user, group,))

    def handle_syscall_entry_chown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        user = event["user"]
        group = event["group"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, user = %s, group = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, user, group,))

    def handle_syscall_entry_fchmod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, mode,))

    def handle_syscall_entry_chmod(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, mode,))

    def handle_syscall_entry_readlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        path = event["path"]
        bufsiz = event["bufsiz"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { path = %s, bufsiz = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, path, bufsiz,))

    def handle_syscall_entry_symlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldname = event["oldname"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldname = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldname, newname,))

    def handle_syscall_entry_unlink(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname,))

    def handle_syscall_entry_link(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldname = event["oldname"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldname = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldname, newname,))

    def handle_syscall_entry_creat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, mode,))

    def handle_syscall_entry_rmdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname,))

    def handle_syscall_entry_mkdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pathname = event["pathname"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pathname = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pathname, mode,))

    def handle_syscall_entry_rename(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldname = event["oldname"]
        newname = event["newname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldname = %s, newname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldname, newname,))

    def handle_syscall_entry_fchdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_syscall_entry_chdir(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename,))

    def handle_syscall_entry_getcwd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, size,))

    def handle_syscall_entry_getdents(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, count,))

    def handle_syscall_entry_ftruncate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        length = event["length"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, length = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, length,))

    def handle_syscall_entry_truncate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        path = event["path"]
        length = event["length"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { path = %s, length = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, path, length,))

    def handle_syscall_entry_fdatasync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_syscall_entry_fsync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_syscall_entry_flock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        cmd = event["cmd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, cmd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, cmd,))

    def handle_syscall_entry_fcntl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, cmd, arg,))

    def handle_syscall_entry_msgctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        msqid = event["msqid"]
        cmd = event["cmd"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { msqid = %s, cmd = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, msqid, cmd, buf,))

    def handle_syscall_entry_msgrcv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        msqid = event["msqid"]
        msgsz = event["msgsz"]
        msgtyp = event["msgtyp"]
        msgflg = event["msgflg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { msqid = %s, msgsz = %s, msgtyp = %s, msgflg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, msqid, msgsz, msgtyp, msgflg,))

    def handle_syscall_entry_msgsnd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        msqid = event["msqid"]
        msgp = event["msgp"]
        msgsz = event["msgsz"]
        msgflg = event["msgflg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { msqid = %s, msgp = %s, msgsz = %s, msgflg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, msqid, msgp, msgsz, msgflg,))

    def handle_syscall_entry_msgget(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        key = event["key"]
        msgflg = event["msgflg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { key = %s, msgflg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, key, msgflg,))

    def handle_syscall_entry_shmdt(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        shmaddr = event["shmaddr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { shmaddr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, shmaddr,))

    def handle_syscall_entry_semctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        semid = event["semid"]
        semnum = event["semnum"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { semid = %s, semnum = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, semid, semnum, cmd, arg,))

    def handle_syscall_entry_semop(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        semid = event["semid"]
        tsops = event["tsops"]
        nsops = event["nsops"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { semid = %s, tsops = %s, nsops = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, semid, tsops, nsops,))

    def handle_syscall_entry_semget(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        key = event["key"]
        nsems = event["nsems"]
        semflg = event["semflg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { key = %s, nsems = %s, semflg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, key, nsems, semflg,))

    def handle_syscall_entry_newuname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_kill(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        sig = event["sig"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, sig = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, sig,))

    def handle_syscall_entry_wait4(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        upid = event["upid"]
        options = event["options"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { upid = %s, options = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, upid, options,))

    def handle_syscall_entry_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        error_code = event["error_code"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { error_code = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, error_code,))

    def handle_syscall_entry_execve(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        argv = event["argv"]
        envp = event["envp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, argv = %s, envp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, argv, envp,))

    def handle_syscall_entry_clone(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clone_flags = event["clone_flags"]
        newsp = event["newsp"]
        parent_tid = event["parent_tid"]
        child_tid = event["child_tid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clone_flags = %s, newsp = %s, parent_tid = %s, child_tid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clone_flags, newsp, parent_tid, child_tid,))

    def handle_syscall_entry_getsockopt(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        level = event["level"]
        optname = event["optname"]
        optlen = event["optlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, level = %s, optname = %s, optlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, level, optname, optlen,))

    def handle_syscall_entry_setsockopt(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        level = event["level"]
        optname = event["optname"]
        optval = event["optval"]
        optlen = event["optlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, level = %s, optname = %s, optval = %s, optlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, level, optname, optval, optlen,))

    def handle_syscall_entry_socketpair(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        family = event["family"]
        type = event["type"]
        protocol = event["protocol"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { family = %s, type = %s, protocol = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, family, type, protocol,))

    def handle_syscall_entry_getpeername(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        usockaddr_len = event["usockaddr_len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, usockaddr_len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, usockaddr_len,))

    def handle_syscall_entry_getsockname(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        usockaddr_len = event["usockaddr_len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, usockaddr_len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, usockaddr_len,))

    def handle_syscall_entry_listen(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        backlog = event["backlog"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, backlog = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, backlog,))

    def handle_syscall_entry_bind(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        umyaddr = event["umyaddr"]
        addrlen = event["addrlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, umyaddr = %s, addrlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, umyaddr, addrlen,))

    def handle_syscall_entry_shutdown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        how = event["how"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, how = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, how,))

    def handle_syscall_entry_recvmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        msg = event["msg"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, msg = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, msg, flags,))

    def handle_syscall_entry_sendmsg(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        msg = event["msg"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, msg = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, msg, flags,))

    def handle_syscall_entry_recvfrom(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        size = event["size"]
        flags = event["flags"]
        addr_len = event["addr_len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, size = %s, flags = %s, addr_len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, size, flags, addr_len,))

    def handle_syscall_entry_sendto(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        buff = event["buff"]
        len = event["len"]
        flags = event["flags"]
        addr = event["addr"]
        addr_len = event["addr_len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, buff = %s, len = %s, flags = %s, addr = %s, addr_len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, buff, len, flags, addr, addr_len,))

    def handle_syscall_entry_accept(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        upeer_sockaddr = event["upeer_sockaddr"]
        upeer_addrlen = event["upeer_addrlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, upeer_sockaddr = %s, upeer_addrlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, upeer_sockaddr, upeer_addrlen,))

    def handle_syscall_entry_connect(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        uservaddr = event["uservaddr"]
        addrlen = event["addrlen"]
        family = event["family"]
        dport = event["dport"]
        _v4addr_length = event["_v4addr_length"]
        v4addr = event["v4addr"]
        _v6addr_length = event["_v6addr_length"]
        v6addr = event["v6addr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, uservaddr = %s, addrlen = %s, family = %s, dport = %s, _v4addr_length = %s, v4addr = %s, _v6addr_length = %s, v6addr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, uservaddr, addrlen, family, dport, _v4addr_length, v4addr, _v6addr_length, v6addr,))

    def handle_syscall_entry_socket(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        family = event["family"]
        type = event["type"]
        protocol = event["protocol"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { family = %s, type = %s, protocol = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, family, type, protocol,))

    def handle_syscall_entry_sendfile64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        out_fd = event["out_fd"]
        in_fd = event["in_fd"]
        offset = event["offset"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { out_fd = %s, in_fd = %s, offset = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, out_fd, in_fd, offset, count,))

    def handle_syscall_entry_getpid(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_setitimer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, value,))

    def handle_syscall_entry_alarm(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        seconds = event["seconds"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { seconds = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, seconds,))

    def handle_syscall_entry_getitimer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which,))

    def handle_syscall_entry_nanosleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rqtp = event["rqtp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rqtp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rqtp,))

    def handle_syscall_entry_pause(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_dup2(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        oldfd = event["oldfd"]
        newfd = event["newfd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { oldfd = %s, newfd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, oldfd, newfd,))

    def handle_syscall_entry_dup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fildes = event["fildes"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fildes = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fildes,))

    def handle_syscall_entry_shmctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        shmid = event["shmid"]
        cmd = event["cmd"]
        buf = event["buf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { shmid = %s, cmd = %s, buf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, shmid, cmd, buf,))

    def handle_syscall_entry_shmat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        shmid = event["shmid"]
        shmaddr = event["shmaddr"]
        shmflg = event["shmflg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { shmid = %s, shmaddr = %s, shmflg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, shmid, shmaddr, shmflg,))

    def handle_syscall_entry_shmget(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        key = event["key"]
        size = event["size"]
        shmflg = event["shmflg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { key = %s, size = %s, shmflg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, key, size, shmflg,))

    def handle_syscall_entry_madvise(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len_in = event["len_in"]
        behavior = event["behavior"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len_in = %s, behavior = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len_in, behavior,))

    def handle_syscall_entry_mincore(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len,))

    def handle_syscall_entry_msync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len, flags,))

    def handle_syscall_entry_mremap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        addr = event["addr"]
        old_len = event["old_len"]
        new_len = event["new_len"]
        flags = event["flags"]
        new_addr = event["new_addr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { addr = %s, old_len = %s, new_len = %s, flags = %s, new_addr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, addr, old_len, new_len, flags, new_addr,))

    def handle_syscall_entry_sched_yield(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_select(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        n = event["n"]
        inp = event["inp"]
        outp = event["outp"]
        exp = event["exp"]
        tvp = event["tvp"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { n = %s, inp = %s, outp = %s, exp = %s, tvp = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, n, inp, outp, exp, tvp,))

    def handle_syscall_entry_pipe(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_syscall_entry_access(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, mode,))

    def handle_syscall_entry_writev(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vec = event["vec"]
        vlen = event["vlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vec = %s, vlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vec, vlen,))

    def handle_syscall_entry_readv(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        vec = event["vec"]
        vlen = event["vlen"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, vec = %s, vlen = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, vec, vlen,))

    def handle_syscall_entry_pwrite64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        buf = event["buf"]
        count = event["count"]
        pos = event["pos"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, buf = %s, count = %s, pos = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, buf, count, pos,))

    def handle_syscall_entry_pread64(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        count = event["count"]
        pos = event["pos"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, count = %s, pos = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, count, pos,))

    def handle_syscall_entry_ioctl(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        cmd = event["cmd"]
        arg = event["arg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, cmd = %s, arg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, cmd, arg,))

    def handle_syscall_entry_rt_sigprocmask(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        how = event["how"]
        nset = event["nset"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { how = %s, nset = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, how, nset, sigsetsize,))

    def handle_syscall_entry_rt_sigaction(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        sig = event["sig"]
        act = event["act"]
        sigsetsize = event["sigsetsize"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { sig = %s, act = %s, sigsetsize = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, sig, act, sigsetsize,))

    def handle_syscall_entry_brk(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        brk = event["brk"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { brk = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, brk,))

    def handle_syscall_entry_munmap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        addr = event["addr"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { addr = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, addr, len,))

    def handle_syscall_entry_mprotect(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        start = event["start"]
        len = event["len"]
        prot = event["prot"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { start = %s, len = %s, prot = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, start, len, prot,))

    def handle_syscall_entry_mmap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        addr = event["addr"]
        len = event["len"]
        prot = event["prot"]
        flags = event["flags"]
        fd = event["fd"]
        offset = event["offset"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { addr = %s, len = %s, prot = %s, flags = %s, fd = %s, offset = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, addr, len, prot, flags, fd, offset,))

    def handle_syscall_entry_lseek(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        offset = event["offset"]
        whence = event["whence"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, offset = %s, whence = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, offset, whence,))

    def handle_syscall_entry_poll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ufds = event["ufds"]
        nfds = event["nfds"]
        timeout_msecs = event["timeout_msecs"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ufds = %s, nfds = %s, timeout_msecs = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ufds, nfds, timeout_msecs,))

    def handle_syscall_entry_newlstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename,))

    def handle_syscall_entry_newfstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_syscall_entry_newstat(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename,))

    def handle_syscall_entry_close(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd,))

    def handle_syscall_entry_open(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        flags = event["flags"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, flags = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, flags, mode,))

    def handle_syscall_entry_write(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        buf = event["buf"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, buf = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, buf, count,))

    def handle_syscall_entry_read(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        fd = event["fd"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { fd = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, fd, count,))

    def handle_syscall_exit_unknown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        id = event["id"]
        ret = event["ret"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { id = %s, ret = %s, args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, id, ret, args,))

    def handle_compat_syscall_exit_unknown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        id = event["id"]
        ret = event["ret"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { id = %s, ret = %s, args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, id, ret, args,))

    def handle_compat_syscall_entry_unknown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        id = event["id"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { id = %s, args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, id, args,))

    def handle_syscall_entry_unknown(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        id = event["id"]
        args = event["args"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { id = %s, args = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, id, args,))

    def handle_lttng_logger(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        _msg_length = event["_msg_length"]
        msg = event["msg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { _msg_length = %s, msg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, _msg_length, msg,))

    def handle_snd_soc_cache_sync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        status = event["status"]
        type = event["type"]
        id = event["id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, status = %s, type = %s, id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, status, type, id,))

    def handle_snd_soc_jack_notify(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, val,))

    def handle_snd_soc_jack_report(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        mask = event["mask"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, mask = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, mask, val,))

    def handle_snd_soc_jack_irq(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_snd_soc_dapm_connected(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        paths = event["paths"]
        stream = event["stream"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { paths = %s, stream = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, paths, stream,))

    def handle_snd_soc_dapm_input_path(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        wname = event["wname"]
        pname = event["pname"]
        psname = event["psname"]
        path_source = event["path_source"]
        path_connect = event["path_connect"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { wname = %s, pname = %s, psname = %s, path_source = %s, path_connect = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, wname, pname, psname, path_source, path_connect,))

    def handle_snd_soc_dapm_output_path(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        wname = event["wname"]
        pname = event["pname"]
        psname = event["psname"]
        path_sink = event["path_sink"]
        path_connect = event["path_connect"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { wname = %s, pname = %s, psname = %s, path_sink = %s, path_connect = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, wname, pname, psname, path_sink, path_connect,))

    def handle_snd_soc_dapm_walk_done(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        power_checks = event["power_checks"]
        path_checks = event["path_checks"]
        neighbour_checks = event["neighbour_checks"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, power_checks = %s, path_checks = %s, neighbour_checks = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, power_checks, path_checks, neighbour_checks,))

    def handle_snd_soc_dapm_widget_event_done(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, val,))

    def handle_snd_soc_dapm_widget_event_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, val,))

    def handle_snd_soc_dapm_widget_power(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, val,))

    def handle_snd_soc_dapm_done(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_snd_soc_dapm_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_snd_soc_bias_level_done(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, val,))

    def handle_snd_soc_bias_level_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, val,))

    def handle_snd_soc_preg_read(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        id = event["id"]
        reg = event["reg"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, id = %s, reg = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, id, reg, val,))

    def handle_snd_soc_preg_write(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        id = event["id"]
        reg = event["reg"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, id = %s, reg = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, id, reg, val,))

    def handle_snd_soc_reg_read(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        id = event["id"]
        reg = event["reg"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, id = %s, reg = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, id, reg, val,))

    def handle_snd_soc_reg_write(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        id = event["id"]
        reg = event["reg"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, id = %s, reg = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, id, reg, val,))

    def handle_block_rq_remap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        old_dev = event["old_dev"]
        old_sector = event["old_sector"]
        rwbs = event["rwbs"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, old_dev = %s, old_sector = %s, rwbs = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, old_dev, old_sector, rwbs,))

    def handle_block_bio_remap(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        old_dev = event["old_dev"]
        old_sector = event["old_sector"]
        rwbs = event["rwbs"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, old_dev = %s, old_sector = %s, rwbs = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, old_dev, old_sector, rwbs,))

    def handle_block_split(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        new_sector = event["new_sector"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, new_sector = %s, rwbs = %s, tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, new_sector, rwbs, tid, comm,))

    def handle_block_unplug(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_rq = event["nr_rq"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_rq = %s, tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_rq, tid, comm,))

    def handle_block_plug(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tid, comm,))

    def handle_block_sleeprq(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, rwbs = %s, tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, rwbs, tid, comm,))

    def handle_block_getrq(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, rwbs = %s, tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, rwbs, tid, comm,))

    def handle_block_bio_queue(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, rwbs = %s, tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, rwbs, tid, comm,))

    def handle_block_bio_frontmerge(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, rwbs = %s, tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, rwbs, tid, comm,))

    def handle_block_bio_backmerge(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, rwbs = %s, tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, rwbs, tid, comm,))

    def handle_block_bio_complete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        error = event["error"]
        rwbs = event["rwbs"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, error = %s, rwbs = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, error, rwbs,))

    def handle_block_bio_bounce(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, rwbs = %s, tid = %s, comm = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, rwbs, tid, comm,))

    def handle_block_rq_issue(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        bytes = event["bytes"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]
        _cmd_length = event["_cmd_length"]
        cmd = event["cmd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, bytes = %s, rwbs = %s, tid = %s, comm = %s, _cmd_length = %s, cmd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, bytes, rwbs, tid, comm, _cmd_length, cmd,))

    def handle_block_rq_insert(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        bytes = event["bytes"]
        rwbs = event["rwbs"]
        tid = event["tid"]
        comm = event["comm"]
        _cmd_length = event["_cmd_length"]
        cmd = event["cmd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, bytes = %s, rwbs = %s, tid = %s, comm = %s, _cmd_length = %s, cmd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, bytes, rwbs, tid, comm, _cmd_length, cmd,))

    def handle_block_rq_complete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        errors = event["errors"]
        rwbs = event["rwbs"]
        _cmd_length = event["_cmd_length"]
        cmd = event["cmd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, errors = %s, rwbs = %s, _cmd_length = %s, cmd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, errors, rwbs, _cmd_length, cmd,))

    def handle_block_rq_requeue(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        errors = event["errors"]
        rwbs = event["rwbs"]
        _cmd_length = event["_cmd_length"]
        cmd = event["cmd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, errors = %s, rwbs = %s, _cmd_length = %s, cmd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, errors, rwbs, _cmd_length, cmd,))

    def handle_block_rq_abort(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        nr_sector = event["nr_sector"]
        errors = event["errors"]
        rwbs = event["rwbs"]
        _cmd_length = event["_cmd_length"]
        cmd = event["cmd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, nr_sector = %s, errors = %s, rwbs = %s, _cmd_length = %s, cmd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, nr_sector, errors, rwbs, _cmd_length, cmd,))

    def handle_block_dirty_buffer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, size,))

    def handle_block_touch_buffer(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sector = event["sector"]
        size = event["size"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sector = %s, size = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sector, size,))

    def handle_mm_compaction_migratepages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_migrated = event["nr_migrated"]
        nr_failed = event["nr_failed"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_migrated = %s, nr_failed = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_migrated, nr_failed,))

    def handle_mm_compaction_isolate_freepages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_scanned = event["nr_scanned"]
        nr_taken = event["nr_taken"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_scanned = %s, nr_taken = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_scanned, nr_taken,))

    def handle_mm_compaction_isolate_migratepages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_scanned = event["nr_scanned"]
        nr_taken = event["nr_taken"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_scanned = %s, nr_taken = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_scanned, nr_taken,))

    def handle_gpio_value(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gpio = event["gpio"]
        get = event["get"]
        value = event["value"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gpio = %s, get = %s, value = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gpio, get, value,))

    def handle_gpio_direction(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gpio = event["gpio"]
        _in = event["in"]
        err = event["err"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gpio = %s, in = %s, err = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gpio, _in, err,))

    def handle_softirq_raise(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, vec,))

    def handle_softirq_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, vec,))

    def handle_softirq_entry(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        vec = event["vec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { vec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, vec,))

    def handle_irq_handler_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        irq = event["irq"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { irq = %s, ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, irq, ret,))

    def handle_irq_handler_entry(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        irq = event["irq"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { irq = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, irq, name,))

    def handle_jbd2_write_superblock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        write_op = event["write_op"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, write_op = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, write_op,))

    def handle_jbd2_update_log_tail(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        tail_sequence = event["tail_sequence"]
        first_tid = event["first_tid"]
        block_nr = event["block_nr"]
        freed = event["freed"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, tail_sequence = %s, first_tid = %s, block_nr = %s, freed = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, tail_sequence, first_tid, block_nr, freed,))

    def handle_jbd2_checkpoint_stats(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        tid = event["tid"]
        chp_time = event["chp_time"]
        forced_to_close = event["forced_to_close"]
        written = event["written"]
        dropped = event["dropped"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, tid = %s, chp_time = %s, forced_to_close = %s, written = %s, dropped = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, tid, chp_time, forced_to_close, written, dropped,))

    def handle_jbd2_run_stats(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        tid = event["tid"]
        wait = event["wait"]
        running = event["running"]
        locked = event["locked"]
        flushing = event["flushing"]
        logging = event["logging"]
        handle_count = event["handle_count"]
        blocks = event["blocks"]
        blocks_logged = event["blocks_logged"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, tid = %s, wait = %s, running = %s, locked = %s, flushing = %s, logging = %s, handle_count = %s, blocks = %s, blocks_logged = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, tid, wait, running, locked, flushing, logging, handle_count, blocks, blocks_logged,))

    def handle_jbd2_submit_inode_data(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        ino = event["ino"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, ino = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, ino,))

    def handle_jbd2_end_commit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sync_commit = event["sync_commit"]
        transaction = event["transaction"]
        head = event["head"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sync_commit = %s, transaction = %s, head = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sync_commit, transaction, head,))

    def handle_jbd2_drop_transaction(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sync_commit = event["sync_commit"]
        transaction = event["transaction"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sync_commit = %s, transaction = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sync_commit, transaction,))

    def handle_jbd2_commit_logging(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sync_commit = event["sync_commit"]
        transaction = event["transaction"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sync_commit = %s, transaction = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sync_commit, transaction,))

    def handle_jbd2_commit_flushing(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sync_commit = event["sync_commit"]
        transaction = event["transaction"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sync_commit = %s, transaction = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sync_commit, transaction,))

    def handle_jbd2_commit_locking(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sync_commit = event["sync_commit"]
        transaction = event["transaction"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sync_commit = %s, transaction = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sync_commit, transaction,))

    def handle_jbd2_start_commit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        sync_commit = event["sync_commit"]
        transaction = event["transaction"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, sync_commit = %s, transaction = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, sync_commit, transaction,))

    def handle_jbd2_checkpoint(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        result = event["result"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, result = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, result,))

    def handle_mm_page_alloc_extfrag(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        page = event["page"]
        alloc_order = event["alloc_order"]
        fallback_order = event["fallback_order"]
        alloc_migratetype = event["alloc_migratetype"]
        fallback_migratetype = event["fallback_migratetype"]
        change_ownership = event["change_ownership"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { page = %s, alloc_order = %s, fallback_order = %s, alloc_migratetype = %s, fallback_migratetype = %s, change_ownership = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, page, alloc_order, fallback_order, alloc_migratetype, fallback_migratetype, change_ownership,))

    def handle_mm_page_pcpu_drain(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        page = event["page"]
        order = event["order"]
        migratetype = event["migratetype"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { page = %s, order = %s, migratetype = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, page, order, migratetype,))

    def handle_mm_page_alloc_zone_locked(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        page = event["page"]
        order = event["order"]
        migratetype = event["migratetype"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { page = %s, order = %s, migratetype = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, page, order, migratetype,))

    def handle_mm_page_alloc(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        page = event["page"]
        order = event["order"]
        gfp_flags = event["gfp_flags"]
        migratetype = event["migratetype"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { page = %s, order = %s, gfp_flags = %s, migratetype = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, page, order, gfp_flags, migratetype,))

    def handle_mm_page_free_batched(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        page = event["page"]
        cold = event["cold"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { page = %s, cold = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, page, cold,))

    def handle_mm_page_free(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        page = event["page"]
        order = event["order"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { page = %s, order = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, page, order,))

    def handle_kmem_cache_free(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        call_site = event["call_site"]
        ptr = event["ptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { call_site = %s, ptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, call_site, ptr,))

    def handle_kmem_kfree(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        call_site = event["call_site"]
        ptr = event["ptr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { call_site = %s, ptr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, call_site, ptr,))

    def handle_kmem_cache_alloc_node(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        call_site = event["call_site"]
        ptr = event["ptr"]
        bytes_req = event["bytes_req"]
        bytes_alloc = event["bytes_alloc"]
        gfp_flags = event["gfp_flags"]
        node = event["node"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { call_site = %s, ptr = %s, bytes_req = %s, bytes_alloc = %s, gfp_flags = %s, node = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node,))

    def handle_kmem_kmalloc_node(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        call_site = event["call_site"]
        ptr = event["ptr"]
        bytes_req = event["bytes_req"]
        bytes_alloc = event["bytes_alloc"]
        gfp_flags = event["gfp_flags"]
        node = event["node"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { call_site = %s, ptr = %s, bytes_req = %s, bytes_alloc = %s, gfp_flags = %s, node = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node,))

    def handle_kmem_cache_alloc(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        call_site = event["call_site"]
        ptr = event["ptr"]
        bytes_req = event["bytes_req"]
        bytes_alloc = event["bytes_alloc"]
        gfp_flags = event["gfp_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { call_site = %s, ptr = %s, bytes_req = %s, bytes_alloc = %s, gfp_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, call_site, ptr, bytes_req, bytes_alloc, gfp_flags,))

    def handle_kmem_kmalloc(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        call_site = event["call_site"]
        ptr = event["ptr"]
        bytes_req = event["bytes_req"]
        bytes_alloc = event["bytes_alloc"]
        gfp_flags = event["gfp_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { call_site = %s, ptr = %s, bytes_req = %s, bytes_alloc = %s, gfp_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, call_site, ptr, bytes_req, bytes_alloc, gfp_flags,))

    def handle_kvm_async_pf_completed(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        address = event["address"]
        gva = event["gva"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { address = %s, gva = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, address, gva,))

    def handle_kvm_async_pf_ready(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        token = event["token"]
        gva = event["gva"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { token = %s, gva = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, token, gva,))

    def handle_kvm_async_pf_not_present(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        token = event["token"]
        gva = event["gva"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { token = %s, gva = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, token, gva,))

    def handle_kvm_async_pf_doublefault(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gva = event["gva"]
        gfn = event["gfn"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gva = %s, gfn = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gva, gfn,))

    def handle_kvm_try_async_get_page(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gva = event["gva"]
        gfn = event["gfn"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gva = %s, gfn = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gva, gfn,))

    def handle_kvm_age_page(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        hva = event["hva"]
        gfn = event["gfn"]
        referenced = event["referenced"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { hva = %s, gfn = %s, referenced = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, hva, gfn, referenced,))

    def handle_kvm_fpu(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        load = event["load"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { load = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, load,))

    def handle_kvm_mmio(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        type = event["type"]
        len = event["len"]
        gpa = event["gpa"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { type = %s, len = %s, gpa = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, type, len, gpa, val,))

    def handle_kvm_ack_irq(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        irqchip = event["irqchip"]
        pin = event["pin"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { irqchip = %s, pin = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, irqchip, pin,))

    def handle_kvm_msi_set_irq(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        address = event["address"]
        data = event["data"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { address = %s, data = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, address, data,))

    def handle_kvm_ioapic_set_irq(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        e = event["e"]
        pin = event["pin"]
        coalesced = event["coalesced"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { e = %s, pin = %s, coalesced = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, e, pin, coalesced,))

    def handle_kvm_set_irq(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        gsi = event["gsi"]
        level = event["level"]
        irq_source_id = event["irq_source_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { gsi = %s, level = %s, irq_source_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, gsi, level, irq_source_id,))

    def handle_kvm_userspace_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        reason = event["reason"]
        errno = event["errno"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { reason = %s, errno = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, reason, errno,))

    def handle_module_request(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ip = event["ip"]
        wait = event["wait"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ip = %s, wait = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ip, wait, name,))

    def handle_module_put(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ip = event["ip"]
        refcnt = event["refcnt"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ip = %s, refcnt = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ip, refcnt, name,))

    def handle_module_get(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ip = event["ip"]
        refcnt = event["refcnt"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ip = %s, refcnt = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ip, refcnt, name,))

    def handle_module_free(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_module_load(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        taints = event["taints"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { taints = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, taints, name,))

    def handle_napi_poll(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        napi = event["napi"]
        dev_name = event["dev_name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { napi = %s, dev_name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, napi, dev_name,))

    def handle_netif_rx(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        skbaddr = event["skbaddr"]
        len = event["len"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { skbaddr = %s, len = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, skbaddr, len, name,))

    def handle_netif_receive_skb(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        skbaddr = event["skbaddr"]
        len = event["len"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { skbaddr = %s, len = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, skbaddr, len, name,))

    def handle_net_dev_queue(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        skbaddr = event["skbaddr"]
        len = event["len"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { skbaddr = %s, len = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, skbaddr, len, name,))

    def handle_net_dev_xmit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        skbaddr = event["skbaddr"]
        len = event["len"]
        rc = event["rc"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { skbaddr = %s, len = %s, rc = %s, name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, skbaddr, len, rc, name,))

    def handle_power_domain_target(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        state = event["state"]
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, state = %s, cpu_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, state, cpu_id,))

    def handle_power_clock_set_rate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        state = event["state"]
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, state = %s, cpu_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, state, cpu_id,))

    def handle_power_clock_disable(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        state = event["state"]
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, state = %s, cpu_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, state, cpu_id,))

    def handle_power_clock_enable(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        state = event["state"]
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, state = %s, cpu_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, state, cpu_id,))

    def handle_power_wakeup_source_deactivate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        state = event["state"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, state = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, state,))

    def handle_power_wakeup_source_activate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        state = event["state"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, state = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, state,))

    def handle_power_machine_suspend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        state = event["state"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { state = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, state,))

    def handle_power_cpu_frequency(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        state = event["state"]
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { state = %s, cpu_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, state, cpu_id,))

    def handle_power_cpu_idle(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        state = event["state"]
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { state = %s, cpu_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, state, cpu_id,))

    def handle_console(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        _msg_length = event["_msg_length"]
        msg = event["msg"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { _msg_length = %s, msg = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, _msg_length, msg,))

    def handle_random_extract_entropy_user(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pool_name = event["pool_name"]
        nbytes = event["nbytes"]
        entropy_count = event["entropy_count"]
        IP = event["IP"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pool_name = %s, nbytes = %s, entropy_count = %s, IP = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pool_name, nbytes, entropy_count, IP,))

    def handle_random_extract_entropy(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pool_name = event["pool_name"]
        nbytes = event["nbytes"]
        entropy_count = event["entropy_count"]
        IP = event["IP"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pool_name = %s, nbytes = %s, entropy_count = %s, IP = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pool_name, nbytes, entropy_count, IP,))

    def handle_random_get_random_bytes(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nbytes = event["nbytes"]
        IP = event["IP"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nbytes = %s, IP = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nbytes, IP,))

    def handle_random_credit_entropy_bits(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pool_name = event["pool_name"]
        bits = event["bits"]
        entropy_count = event["entropy_count"]
        entropy_total = event["entropy_total"]
        IP = event["IP"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pool_name = %s, bits = %s, entropy_count = %s, entropy_total = %s, IP = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pool_name, bits, entropy_count, entropy_total, IP,))

    def handle_random_mix_pool_bytes_nolock(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pool_name = event["pool_name"]
        bytes = event["bytes"]
        IP = event["IP"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pool_name = %s, bytes = %s, IP = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pool_name, bytes, IP,))

    def handle_random_mix_pool_bytes(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pool_name = event["pool_name"]
        bytes = event["bytes"]
        IP = event["IP"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pool_name = %s, bytes = %s, IP = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pool_name, bytes, IP,))

    def handle_rcu_utilization(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        s = event["s"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { s = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, s,))

    def handle_regmap_cache_bypass(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, flag,))

    def handle_regmap_cache_only(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, flag,))

    def handle_regcache_sync(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        status = event["status"]
        type = event["type"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, status = %s, type = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, status, type,))

    def handle_regmap_hw_write_done(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        reg = event["reg"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, reg = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, reg, count,))

    def handle_regmap_hw_write_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        reg = event["reg"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, reg = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, reg, count,))

    def handle_regmap_hw_read_done(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        reg = event["reg"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, reg = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, reg, count,))

    def handle_regmap_hw_read_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        reg = event["reg"]
        count = event["count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, reg = %s, count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, reg, count,))

    def handle_regmap_reg_read_cache(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        reg = event["reg"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, reg = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, reg, val,))

    def handle_regmap_reg_read(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        reg = event["reg"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, reg = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, reg, val,))

    def handle_regmap_reg_write(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        reg = event["reg"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, reg = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, reg, val,))

    def handle_regulator_set_voltage_complete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        val = event["val"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, val = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, val,))

    def handle_regulator_set_voltage(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        min = event["min"]
        max = event["max"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, min = %s, max = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, min, max,))

    def handle_regulator_disable_complete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_regulator_disable(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_regulator_enable_complete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_regulator_enable_delay(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_regulator_enable(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_rpm_return_int(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        ip = event["ip"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, ip = %s, ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, ip, ret,))

    def handle_rpm_idle(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        flags = event["flags"]
        usage_count = event["usage_count"]
        disable_depth = event["disable_depth"]
        runtime_auto = event["runtime_auto"]
        request_pending = event["request_pending"]
        irq_safe = event["irq_safe"]
        child_count = event["child_count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, flags = %s, usage_count = %s, disable_depth = %s, runtime_auto = %s, request_pending = %s, irq_safe = %s, child_count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, flags, usage_count, disable_depth, runtime_auto, request_pending, irq_safe, child_count,))

    def handle_rpm_resume(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        flags = event["flags"]
        usage_count = event["usage_count"]
        disable_depth = event["disable_depth"]
        runtime_auto = event["runtime_auto"]
        request_pending = event["request_pending"]
        irq_safe = event["irq_safe"]
        child_count = event["child_count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, flags = %s, usage_count = %s, disable_depth = %s, runtime_auto = %s, request_pending = %s, irq_safe = %s, child_count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, flags, usage_count, disable_depth, runtime_auto, request_pending, irq_safe, child_count,))

    def handle_rpm_suspend(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        flags = event["flags"]
        usage_count = event["usage_count"]
        disable_depth = event["disable_depth"]
        runtime_auto = event["runtime_auto"]
        request_pending = event["request_pending"]
        irq_safe = event["irq_safe"]
        child_count = event["child_count"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, flags = %s, usage_count = %s, disable_depth = %s, runtime_auto = %s, request_pending = %s, irq_safe = %s, child_count = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, flags, usage_count, disable_depth, runtime_auto, request_pending, irq_safe, child_count,))

    def handle_sched_pi_setprio(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        oldprio = event["oldprio"]
        newprio = event["newprio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, oldprio = %s, newprio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, oldprio, newprio,))

    def handle_sched_stat_runtime(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        runtime = event["runtime"]
        vruntime = event["vruntime"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, runtime = %s, vruntime = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, runtime, vruntime,))

    def handle_sched_stat_blocked(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        delay = event["delay"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, delay = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, delay,))

    def handle_sched_stat_iowait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        delay = event["delay"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, delay = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, delay,))

    def handle_sched_stat_sleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        delay = event["delay"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, delay = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, delay,))

    def handle_sched_stat_wait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        delay = event["delay"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, delay = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, delay,))

    def handle_sched_process_exec(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        filename = event["filename"]
        tid = event["tid"]
        old_tid = event["old_tid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { filename = %s, tid = %s, old_tid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, filename, tid, old_tid,))

    def handle_sched_process_fork(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        parent_comm = event["parent_comm"]
        parent_tid = event["parent_tid"]
        parent_pid = event["parent_pid"]
        child_comm = event["child_comm"]
        child_tid = event["child_tid"]
        child_pid = event["child_pid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { parent_comm = %s, parent_tid = %s, parent_pid = %s, child_comm = %s, child_tid = %s, child_pid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, parent_comm, parent_tid, parent_pid, child_comm, child_tid, child_pid,))

    def handle_sched_process_wait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        prio = event["prio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, prio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, prio,))

    def handle_sched_wait_task(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        prio = event["prio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, prio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, prio,))

    def handle_sched_process_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        prio = event["prio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, prio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, prio,))

    def handle_sched_process_free(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        prio = event["prio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, prio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, prio,))

    def handle_sched_migrate_task(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        prio = event["prio"]
        orig_cpu = event["orig_cpu"]
        dest_cpu = event["dest_cpu"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, prio = %s, orig_cpu = %s, dest_cpu = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, prio, orig_cpu, dest_cpu,))

    def handle_sched_switch(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        prev_comm = event["prev_comm"]
        prev_tid = event["prev_tid"]
        prev_prio = event["prev_prio"]
        prev_state = event["prev_state"]
        next_comm = event["next_comm"]
        next_tid = event["next_tid"]
        next_prio = event["next_prio"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { prev_comm = %s, prev_tid = %s, prev_prio = %s, prev_state = %s, next_comm = %s, next_tid = %s, next_prio = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, prev_comm, prev_tid, prev_prio, prev_state, next_comm, next_tid, next_prio,))

    def handle_sched_wakeup_new(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        prio = event["prio"]
        success = event["success"]
        target_cpu = event["target_cpu"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, prio = %s, success = %s, target_cpu = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, prio, success, target_cpu,))

    def handle_sched_wakeup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]
        prio = event["prio"]
        success = event["success"]
        target_cpu = event["target_cpu"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s, prio = %s, success = %s, target_cpu = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid, prio, success, target_cpu,))

    def handle_sched_kthread_stop_ret(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        ret = event["ret"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { ret = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, ret,))

    def handle_sched_kthread_stop(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        tid = event["tid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, tid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, tid,))

    def handle_scsi_eh_wakeup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        host_no = event["host_no"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { host_no = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, host_no,))

    def handle_scsi_dispatch_cmd_timeout(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        host_no = event["host_no"]
        channel = event["channel"]
        id = event["id"]
        lun = event["lun"]
        result = event["result"]
        opcode = event["opcode"]
        cmd_len = event["cmd_len"]
        data_sglen = event["data_sglen"]
        prot_sglen = event["prot_sglen"]
        prot_op = event["prot_op"]
        _cmnd_length = event["_cmnd_length"]
        cmnd = event["cmnd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { host_no = %s, channel = %s, id = %s, lun = %s, result = %s, opcode = %s, cmd_len = %s, data_sglen = %s, prot_sglen = %s, prot_op = %s, _cmnd_length = %s, cmnd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, host_no, channel, id, lun, result, opcode, cmd_len, data_sglen, prot_sglen, prot_op, _cmnd_length, cmnd,))

    def handle_scsi_dispatch_cmd_done(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        host_no = event["host_no"]
        channel = event["channel"]
        id = event["id"]
        lun = event["lun"]
        result = event["result"]
        opcode = event["opcode"]
        cmd_len = event["cmd_len"]
        data_sglen = event["data_sglen"]
        prot_sglen = event["prot_sglen"]
        prot_op = event["prot_op"]
        _cmnd_length = event["_cmnd_length"]
        cmnd = event["cmnd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { host_no = %s, channel = %s, id = %s, lun = %s, result = %s, opcode = %s, cmd_len = %s, data_sglen = %s, prot_sglen = %s, prot_op = %s, _cmnd_length = %s, cmnd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, host_no, channel, id, lun, result, opcode, cmd_len, data_sglen, prot_sglen, prot_op, _cmnd_length, cmnd,))

    def handle_scsi_dispatch_cmd_error(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        host_no = event["host_no"]
        channel = event["channel"]
        id = event["id"]
        lun = event["lun"]
        rtn = event["rtn"]
        opcode = event["opcode"]
        cmd_len = event["cmd_len"]
        data_sglen = event["data_sglen"]
        prot_sglen = event["prot_sglen"]
        prot_op = event["prot_op"]
        _cmnd_length = event["_cmnd_length"]
        cmnd = event["cmnd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { host_no = %s, channel = %s, id = %s, lun = %s, rtn = %s, opcode = %s, cmd_len = %s, data_sglen = %s, prot_sglen = %s, prot_op = %s, _cmnd_length = %s, cmnd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, host_no, channel, id, lun, rtn, opcode, cmd_len, data_sglen, prot_sglen, prot_op, _cmnd_length, cmnd,))

    def handle_scsi_dispatch_cmd_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        host_no = event["host_no"]
        channel = event["channel"]
        id = event["id"]
        lun = event["lun"]
        opcode = event["opcode"]
        cmd_len = event["cmd_len"]
        data_sglen = event["data_sglen"]
        prot_sglen = event["prot_sglen"]
        prot_op = event["prot_op"]
        _cmnd_length = event["_cmnd_length"]
        cmnd = event["cmnd"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { host_no = %s, channel = %s, id = %s, lun = %s, opcode = %s, cmd_len = %s, data_sglen = %s, prot_sglen = %s, prot_op = %s, _cmnd_length = %s, cmnd = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, host_no, channel, id, lun, opcode, cmd_len, data_sglen, prot_sglen, prot_op, _cmnd_length, cmnd,))

    def handle_signal_deliver(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        sig = event["sig"]
        errno = event["errno"]
        code = event["code"]
        sa_handler = event["sa_handler"]
        sa_flags = event["sa_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { sig = %s, errno = %s, code = %s, sa_handler = %s, sa_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, sig, errno, code, sa_handler, sa_flags,))

    def handle_signal_generate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        sig = event["sig"]
        errno = event["errno"]
        code = event["code"]
        comm = event["comm"]
        pid = event["pid"]
        group = event["group"]
        result = event["result"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { sig = %s, errno = %s, code = %s, comm = %s, pid = %s, group = %s, result = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, sig, errno, code, comm, pid, group, result,))

    def handle_skb_copy_datagram_iovec(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        skbaddr = event["skbaddr"]
        len = event["len"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { skbaddr = %s, len = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, skbaddr, len,))

    def handle_skb_consume(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        skbaddr = event["skbaddr"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { skbaddr = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, skbaddr,))

    def handle_skb_kfree(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        skbaddr = event["skbaddr"]
        location = event["location"]
        protocol = event["protocol"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { skbaddr = %s, location = %s, protocol = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, skbaddr, location, protocol,))

    def handle_sock_exceed_buf_limit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        sysctl_mem = event["sysctl_mem"]
        allocated = event["allocated"]
        sysctl_rmem = event["sysctl_rmem"]
        rmem_alloc = event["rmem_alloc"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, sysctl_mem = %s, allocated = %s, sysctl_rmem = %s, rmem_alloc = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, sysctl_mem, allocated, sysctl_rmem, rmem_alloc,))

    def handle_sock_rcvqueue_full(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rmem_alloc = event["rmem_alloc"]
        truesize = event["truesize"]
        sk_rcvbuf = event["sk_rcvbuf"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rmem_alloc = %s, truesize = %s, sk_rcvbuf = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rmem_alloc, truesize, sk_rcvbuf,))

    def handle_lttng_statedump_interrupt(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        irq = event["irq"]
        name = event["name"]
        action = event["action"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { irq = %s, name = %s, action = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, irq, name, action,))

    def handle_lttng_statedump_block_device(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        dev = event["dev"]
        diskname = event["diskname"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { dev = %s, diskname = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, dev, diskname,))

    def handle_lttng_statedump_network_interface(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        address_ipv4 = event["address_ipv4"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, address_ipv4 = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, address_ipv4,))

    def handle_lttng_statedump_vm_map(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        start = event["start"]
        end = event["end"]
        flags = event["flags"]
        inode = event["inode"]
        pgoff = event["pgoff"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, start = %s, end = %s, flags = %s, inode = %s, pgoff = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, start, end, flags, inode, pgoff,))

    def handle_lttng_statedump_file_descriptor(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pid = event["pid"]
        fd = event["fd"]
        flags = event["flags"]
        fmode = event["fmode"]
        filename = event["filename"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pid = %s, fd = %s, flags = %s, fmode = %s, filename = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pid, fd, flags, fmode, filename,))

    def handle_lttng_statedump_process_state(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        tid = event["tid"]
        vtid = event["vtid"]
        pid = event["pid"]
        vpid = event["vpid"]
        ppid = event["ppid"]
        vppid = event["vppid"]
        name = event["name"]
        type = event["type"]
        mode = event["mode"]
        submode = event["submode"]
        status = event["status"]
        ns_level = event["ns_level"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { tid = %s, vtid = %s, pid = %s, vpid = %s, ppid = %s, vppid = %s, name = %s, type = %s, mode = %s, submode = %s, status = %s, ns_level = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, tid, vtid, pid, vpid, ppid, vppid, name, type, mode, submode, status, ns_level,))

    def handle_lttng_statedump_end(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_lttng_statedump_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s },  }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id,))

    def handle_rpc_task_wakeup(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clnt = event["clnt"]
        task = event["task"]
        timeout = event["timeout"]
        runstate = event["runstate"]
        status = event["status"]
        flags = event["flags"]
        q_name = event["q_name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clnt = %s, task = %s, timeout = %s, runstate = %s, status = %s, flags = %s, q_name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clnt, task, timeout, runstate, status, flags, q_name,))

    def handle_rpc_task_sleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clnt = event["clnt"]
        task = event["task"]
        timeout = event["timeout"]
        runstate = event["runstate"]
        status = event["status"]
        flags = event["flags"]
        q_name = event["q_name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clnt = %s, task = %s, timeout = %s, runstate = %s, status = %s, flags = %s, q_name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clnt, task, timeout, runstate, status, flags, q_name,))

    def handle_rpc_task_complete(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clnt = event["clnt"]
        task = event["task"]
        action = event["action"]
        runstate = event["runstate"]
        status = event["status"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clnt = %s, task = %s, action = %s, runstate = %s, status = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clnt, task, action, runstate, status, flags,))

    def handle_rpc_task_run_action(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clnt = event["clnt"]
        task = event["task"]
        action = event["action"]
        runstate = event["runstate"]
        status = event["status"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clnt = %s, task = %s, action = %s, runstate = %s, status = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clnt, task, action, runstate, status, flags,))

    def handle_rpc_task_begin(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        clnt = event["clnt"]
        task = event["task"]
        action = event["action"]
        runstate = event["runstate"]
        status = event["status"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { clnt = %s, task = %s, action = %s, runstate = %s, status = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, clnt, task, action, runstate, status, flags,))

    def handle_rpc_connect_status(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        task = event["task"]
        clnt = event["clnt"]
        status = event["status"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { task = %s, clnt = %s, status = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, task, clnt, status,))

    def handle_rpc_bind_status(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        task = event["task"]
        clnt = event["clnt"]
        status = event["status"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { task = %s, clnt = %s, status = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, task, clnt, status,))

    def handle_rpc_call_status(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        task = event["task"]
        clnt = event["clnt"]
        status = event["status"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { task = %s, clnt = %s, status = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, task, clnt, status,))

    def handle_itimer_expire(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        pid = event["pid"]
        now = event["now"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, pid = %s, now = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, pid, now,))

    def handle_itimer_state(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        which = event["which"]
        expires = event["expires"]
        value_sec = event["value_sec"]
        value_usec = event["value_usec"]
        interval_sec = event["interval_sec"]
        interval_usec = event["interval_usec"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { which = %s, expires = %s, value_sec = %s, value_usec = %s, interval_sec = %s, interval_usec = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, which, expires, value_sec, value_usec, interval_sec, interval_usec,))

    def handle_hrtimer_cancel(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        hrtimer = event["hrtimer"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { hrtimer = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, hrtimer,))

    def handle_hrtimer_expire_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        hrtimer = event["hrtimer"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { hrtimer = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, hrtimer,))

    def handle_hrtimer_expire_entry(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        hrtimer = event["hrtimer"]
        now = event["now"]
        function = event["function"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { hrtimer = %s, now = %s, function = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, hrtimer, now, function,))

    def handle_hrtimer_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        hrtimer = event["hrtimer"]
        function = event["function"]
        expires = event["expires"]
        softexpires = event["softexpires"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { hrtimer = %s, function = %s, expires = %s, softexpires = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, hrtimer, function, expires, softexpires,))

    def handle_hrtimer_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        hrtimer = event["hrtimer"]
        clockid = event["clockid"]
        mode = event["mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { hrtimer = %s, clockid = %s, mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, hrtimer, clockid, mode,))

    def handle_timer_cancel(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer = event["timer"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer,))

    def handle_timer_expire_exit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer = event["timer"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer,))

    def handle_timer_expire_entry(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer = event["timer"]
        now = event["now"]
        function = event["function"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer = %s, now = %s, function = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer, now, function,))

    def handle_timer_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer = event["timer"]
        function = event["function"]
        expires = event["expires"]
        now = event["now"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer = %s, function = %s, expires = %s, now = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer, function, expires, now,))

    def handle_timer_init(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        timer = event["timer"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { timer = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, timer,))

    def handle_udp_fail_queue_rcv_skb(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        rc = event["rc"]
        lport = event["lport"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { rc = %s, lport = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, rc, lport,))

    def handle_mm_vmscan_lru_shrink_inactive(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nid = event["nid"]
        zid = event["zid"]
        nr_scanned = event["nr_scanned"]
        nr_reclaimed = event["nr_reclaimed"]
        priority = event["priority"]
        reclaim_flags = event["reclaim_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nid = %s, zid = %s, nr_scanned = %s, nr_reclaimed = %s, priority = %s, reclaim_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nid, zid, nr_scanned, nr_reclaimed, priority, reclaim_flags,))

    def handle_mm_vmscan_writepage(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        page = event["page"]
        reclaim_flags = event["reclaim_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { page = %s, reclaim_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, page, reclaim_flags,))

    def handle_mm_vmscan_memcg_isolate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        order = event["order"]
        nr_requested = event["nr_requested"]
        nr_scanned = event["nr_scanned"]
        nr_taken = event["nr_taken"]
        isolate_mode = event["isolate_mode"]
        file = event["file"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { order = %s, nr_requested = %s, nr_scanned = %s, nr_taken = %s, isolate_mode = %s, file = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, order, nr_requested, nr_scanned, nr_taken, isolate_mode, file,))

    def handle_mm_vmscan_lru_isolate(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        order = event["order"]
        nr_requested = event["nr_requested"]
        nr_scanned = event["nr_scanned"]
        nr_taken = event["nr_taken"]
        isolate_mode = event["isolate_mode"]
        file = event["file"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { order = %s, nr_requested = %s, nr_scanned = %s, nr_taken = %s, isolate_mode = %s, file = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, order, nr_requested, nr_scanned, nr_taken, isolate_mode, file,))

    def handle_mm_shrink_slab_end(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        shr = event["shr"]
        shrink = event["shrink"]
        unused_scan = event["unused_scan"]
        new_scan = event["new_scan"]
        retval = event["retval"]
        total_scan = event["total_scan"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { shr = %s, shrink = %s, unused_scan = %s, new_scan = %s, retval = %s, total_scan = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, shr, shrink, unused_scan, new_scan, retval, total_scan,))

    def handle_mm_shrink_slab_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        shr = event["shr"]
        shrink = event["shrink"]
        nr_objects_to_shrink = event["nr_objects_to_shrink"]
        gfp_flags = event["gfp_flags"]
        pgs_scanned = event["pgs_scanned"]
        lru_pgs = event["lru_pgs"]
        cache_items = event["cache_items"]
        delta = event["delta"]
        total_scan = event["total_scan"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { shr = %s, shrink = %s, nr_objects_to_shrink = %s, gfp_flags = %s, pgs_scanned = %s, lru_pgs = %s, cache_items = %s, delta = %s, total_scan = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, shr, shrink, nr_objects_to_shrink, gfp_flags, pgs_scanned, lru_pgs, cache_items, delta, total_scan,))

    def handle_mm_vmscan_memcg_softlimit_reclaim_end(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_reclaimed = event["nr_reclaimed"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_reclaimed = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_reclaimed,))

    def handle_mm_vmscan_memcg_reclaim_end(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_reclaimed = event["nr_reclaimed"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_reclaimed = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_reclaimed,))

    def handle_mm_vmscan_direct_reclaim_end(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_reclaimed = event["nr_reclaimed"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_reclaimed = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_reclaimed,))

    def handle_mm_vmscan_memcg_softlimit_reclaim_begin(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        order = event["order"]
        may_writepage = event["may_writepage"]
        gfp_flags = event["gfp_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { order = %s, may_writepage = %s, gfp_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, order, may_writepage, gfp_flags,))

    def handle_mm_vmscan_memcg_reclaim_begin(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        order = event["order"]
        may_writepage = event["may_writepage"]
        gfp_flags = event["gfp_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { order = %s, may_writepage = %s, gfp_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, order, may_writepage, gfp_flags,))

    def handle_mm_vmscan_direct_reclaim_begin(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        order = event["order"]
        may_writepage = event["may_writepage"]
        gfp_flags = event["gfp_flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { order = %s, may_writepage = %s, gfp_flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, order, may_writepage, gfp_flags,))

    def handle_mm_vmscan_wakeup_kswapd(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nid = event["nid"]
        zid = event["zid"]
        order = event["order"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nid = %s, zid = %s, order = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nid, zid, order,))

    def handle_mm_vmscan_kswapd_wake(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nid = event["nid"]
        order = event["order"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nid = %s, order = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nid, order,))

    def handle_mm_vmscan_kswapd_sleep(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nid = event["nid"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nid = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nid,))

    def handle_workqueue_execute_end(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        work = event["work"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { work = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, work,))

    def handle_workqueue_execute_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        work = event["work"]
        function = event["function"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { work = %s, function = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, work, function,))

    def handle_workqueue_activate_work(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        work = event["work"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { work = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, work,))

    def handle_workqueue_queue_work(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        work = event["work"]
        function = event["function"]
        req_cpu = event["req_cpu"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { work = %s, function = %s, req_cpu = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, work, function, req_cpu,))

    def handle_writeback_single_inode(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        ino = event["ino"]
        state = event["state"]
        dirtied_when = event["dirtied_when"]
        writeback_index = event["writeback_index"]
        nr_to_write = event["nr_to_write"]
        wrote = event["wrote"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, ino = %s, state = %s, dirtied_when = %s, writeback_index = %s, nr_to_write = %s, wrote = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, ino, state, dirtied_when, writeback_index, nr_to_write, wrote,))

    def handle_writeback_wait_iff_congested(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        usec_timeout = event["usec_timeout"]
        usec_delayed = event["usec_delayed"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { usec_timeout = %s, usec_delayed = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, usec_timeout, usec_delayed,))

    def handle_writeback_congestion_wait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        usec_timeout = event["usec_timeout"]
        usec_delayed = event["usec_delayed"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { usec_timeout = %s, usec_delayed = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, usec_timeout, usec_delayed,))

    def handle_writeback_sb_inodes_requeue(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        ino = event["ino"]
        state = event["state"]
        dirtied_when = event["dirtied_when"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, ino = %s, state = %s, dirtied_when = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, ino, state, dirtied_when,))

    def handle_writeback_balance_dirty_pages(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        bdi = event["bdi"]
        limit = event["limit"]
        setpoint = event["setpoint"]
        dirty = event["dirty"]
        bdi_setpoint = event["bdi_setpoint"]
        bdi_dirty = event["bdi_dirty"]
        dirty_ratelimit = event["dirty_ratelimit"]
        task_ratelimit = event["task_ratelimit"]
        dirtied = event["dirtied"]
        dirtied_pause = event["dirtied_pause"]
        paused = event["paused"]
        pause = event["pause"]
        period = event["period"]
        think = event["think"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { bdi = %s, limit = %s, setpoint = %s, dirty = %s, bdi_setpoint = %s, bdi_dirty = %s, dirty_ratelimit = %s, task_ratelimit = %s, dirtied = %s, dirtied_pause = %s, paused = %s, pause = %s, period = %s, think = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, bdi, limit, setpoint, dirty, bdi_setpoint, bdi_dirty, dirty_ratelimit, task_ratelimit, dirtied, dirtied_pause, paused, pause, period, think,))

    def handle_writeback_bdi_dirty_ratelimit(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        bdi = event["bdi"]
        write_bw = event["write_bw"]
        avg_write_bw = event["avg_write_bw"]
        dirty_rate = event["dirty_rate"]
        dirty_ratelimit = event["dirty_ratelimit"]
        task_ratelimit = event["task_ratelimit"]
        balanced_dirty_ratelimit = event["balanced_dirty_ratelimit"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { bdi = %s, write_bw = %s, avg_write_bw = %s, dirty_rate = %s, dirty_ratelimit = %s, task_ratelimit = %s, balanced_dirty_ratelimit = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, bdi, write_bw, avg_write_bw, dirty_rate, dirty_ratelimit, task_ratelimit, balanced_dirty_ratelimit,))

    def handle_writeback_global_dirty_state(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        nr_dirty = event["nr_dirty"]
        nr_writeback = event["nr_writeback"]
        nr_unstable = event["nr_unstable"]
        background_thresh = event["background_thresh"]
        dirty_thresh = event["dirty_thresh"]
        dirty_limit = event["dirty_limit"]
        nr_dirtied = event["nr_dirtied"]
        nr_written = event["nr_written"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { nr_dirty = %s, nr_writeback = %s, nr_unstable = %s, background_thresh = %s, dirty_thresh = %s, dirty_limit = %s, nr_dirtied = %s, nr_written = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, nr_dirty, nr_writeback, nr_unstable, background_thresh, dirty_thresh, dirty_limit, nr_dirtied, nr_written,))

    def handle_writeback_queue_io(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        moved = event["moved"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, moved = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, moved,))

    def handle_writeback_wbc_writepage(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        nr_to_write = event["nr_to_write"]
        pages_skipped = event["pages_skipped"]
        sync_mode = event["sync_mode"]
        for_kupdate = event["for_kupdate"]
        for_background = event["for_background"]
        for_reclaim = event["for_reclaim"]
        range_cyclic = event["range_cyclic"]
        range_start = event["range_start"]
        range_end = event["range_end"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, nr_to_write = %s, pages_skipped = %s, sync_mode = %s, for_kupdate = %s, for_background = %s, for_reclaim = %s, range_cyclic = %s, range_start = %s, range_end = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, nr_to_write, pages_skipped, sync_mode, for_kupdate, for_background, for_reclaim, range_cyclic, range_start, range_end,))

    def handle_writeback_thread_stop(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_thread_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_bdi_unregister(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_bdi_register(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_wake_forker_thread(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_wake_thread(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_wake_background(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_nowork(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_pages_written(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        pages = event["pages"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { pages = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, pages,))

    def handle_writeback_wait(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_written(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_exec(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_queue(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_nothread(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name,))

    def handle_writeback_write_inode(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        ino = event["ino"]
        sync_mode = event["sync_mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, ino = %s, sync_mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, ino, sync_mode,))

    def handle_writeback_write_inode_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        ino = event["ino"]
        sync_mode = event["sync_mode"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, ino = %s, sync_mode = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, ino, sync_mode,))

    def handle_writeback_dirty_inode(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        ino = event["ino"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, ino = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, ino, flags,))

    def handle_writeback_dirty_inode_start(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        ino = event["ino"]
        flags = event["flags"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, ino = %s, flags = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, ino, flags,))

    def handle_writeback_dirty_page(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        ino = event["ino"]
        index = event["index"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, ino = %s, index = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, ino, index,))

    def handle_net_latency(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        name = event["name"]
        delay = event["delay"]
        flag = event["flag"]
        out_id = event["out_id"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { name = %s, delay = %s, flag = %s, out_id = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, name, delay, flag, out_id,))

    def handle_block_latency(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        major = event["major"]
        minor = event["minor"]
        sector = event["sector"]
        delay = event["delay"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { major = %s, minor = %s, sector = %s, delay = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, major, minor, sector, delay,))

    def handle_offcpu_latency(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        pid = event["pid"]
        delay = event["delay"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, pid = %s, delay = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, pid, delay, flag,))

    def handle_wakeup_latency(self, event):
        timestamp = event.timestamp
        cpu_id = event["cpu_id"]
        comm = event["comm"]
        pid = event["pid"]
        delay = event["delay"]
        flag = event["flag"]

        self.print_filter(event, "[%s] %s: { cpu_id = %s }, { comm = %s, pid = %s, delay = %s, flag = %s }" % (self.ns_to_hour_nsec(timestamp), event.name, cpu_id, comm, pid, delay, flag,))
    # end of generated code


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Track a process throughout a LTTng trace')
    parser.add_argument('path', metavar="<path/to/trace>", help='Trace path')
    parser.add_argument('--procname', '-n', type=str, default=0,
                    help='Filter the results only for this list of '
                         'process names')
    parser.add_argument('--tid', '-t', type=str, default=0,
                    help='Filter the results only for this list '
                         'of TIDs')
    parser.add_argument('--follow-child', '-f', action="store_true",
            help='Follow children on fork')
    args = parser.parse_args()

    arg_proc_list = None
    if args.procname:
        arg_proc_list = args.procname.split(",")
    arg_tid_list = None
    if args.tid:
        arg_tid_list = []
        for i in args.tid.split(","):
            arg_tid_list.append(int(i))

    traces = TraceCollection()
    handle = traces.add_traces_recursive(args.path, "ctf")
    if handle is None:
        sys.exit(1)

    t = TraceParser(traces, arg_proc_list, arg_tid_list, args.follow_child)
    t.parse()

    for h in handle.values():
        traces.remove_trace(h)