%{
#include </home/acme/git/pahole/lib/ctracer_relay.h>
%}
function ctracer__method_hook(probe_type, func, object, state_len)
%{
	ctracer__method_hook(_stp_gettimeofday_ns(), THIS->probe_type, THIS->func, (void *)THIS->object, THIS->state_len);
%}

probe audit_receive = kernel.function("audit_receive")
{
}

probe audit_receive
{
	ctracer__method_hook(0, 0x4cb307, $sk, 80);
}

probe audit_receive__return = kernel.function("audit_receive").return
{
}

probe audit_receive__return
{
	ctracer__method_hook(1, 0x4cb307, $sk, 80);
}

probe dummy_inet_conn_established = kernel.function("dummy_inet_conn_established")
{
}

probe dummy_inet_conn_established
{
	ctracer__method_hook(0, 0xb708fc, $sk, 80);
}

probe dummy_inet_conn_established__return = kernel.function("dummy_inet_conn_established").return
{
}

probe dummy_inet_conn_established__return
{
	ctracer__method_hook(1, 0xb708fc, $sk, 80);
}

probe dummy_inet_csk_clone = kernel.function("dummy_inet_csk_clone")
{
}

probe dummy_inet_csk_clone
{
	ctracer__method_hook(0, 0xb708bf, $newsk, 80);
}

probe dummy_inet_csk_clone__return = kernel.function("dummy_inet_csk_clone").return
{
}

probe dummy_inet_csk_clone__return
{
	ctracer__method_hook(1, 0xb708bf, $newsk, 80);
}

probe dummy_inet_conn_request = kernel.function("dummy_inet_conn_request")
{
}

probe dummy_inet_conn_request
{
	ctracer__method_hook(0, 0xb70871, $sk, 80);
}

probe dummy_inet_conn_request__return = kernel.function("dummy_inet_conn_request").return
{
}

probe dummy_inet_conn_request__return
{
	ctracer__method_hook(1, 0xb70871, $sk, 80);
}

probe dummy_sock_graft = kernel.function("dummy_sock_graft")
{
}

probe dummy_sock_graft
{
	ctracer__method_hook(0, 0xb70835, $sk, 80);
}

probe dummy_sock_graft__return = kernel.function("dummy_sock_graft").return
{
}

probe dummy_sock_graft__return
{
	ctracer__method_hook(1, 0xb70835, $sk, 80);
}

probe dummy_sk_getsecid = kernel.function("dummy_sk_getsecid")
{
}

probe dummy_sk_getsecid
{
	ctracer__method_hook(0, 0xb707f9, $sk, 80);
}

probe dummy_sk_getsecid__return = kernel.function("dummy_sk_getsecid").return
{
}

probe dummy_sk_getsecid__return
{
	ctracer__method_hook(1, 0xb707f9, $sk, 80);
}

probe dummy_sk_clone_security = kernel.function("dummy_sk_clone_security")
{
}

probe dummy_sk_clone_security
{
	ctracer__method_hook(0, 0xb707bd, $newsk, 80);
}

probe dummy_sk_clone_security__return = kernel.function("dummy_sk_clone_security").return
{
}

probe dummy_sk_clone_security__return
{
	ctracer__method_hook(1, 0xb707bd, $newsk, 80);
}

probe dummy_sk_free_security = kernel.function("dummy_sk_free_security")
{
}

probe dummy_sk_free_security
{
	ctracer__method_hook(0, 0xb7078f, $sk, 80);
}

probe dummy_sk_free_security__return = kernel.function("dummy_sk_free_security").return
{
}

probe dummy_sk_free_security__return
{
	ctracer__method_hook(1, 0xb7078f, $sk, 80);
}

probe dummy_sk_alloc_security = kernel.function("dummy_sk_alloc_security")
{
}

probe dummy_sk_alloc_security
{
	ctracer__method_hook(0, 0xb70741, $sk, 80);
}

probe dummy_sk_alloc_security__return = kernel.function("dummy_sk_alloc_security").return
{
}

probe dummy_sk_alloc_security__return
{
	ctracer__method_hook(1, 0xb70741, $sk, 80);
}

probe dummy_socket_sock_rcv_skb = kernel.function("dummy_socket_sock_rcv_skb")
{
}

probe dummy_socket_sock_rcv_skb
{
	ctracer__method_hook(0, 0xb70655, $sk, 80);
}

probe dummy_socket_sock_rcv_skb__return = kernel.function("dummy_socket_sock_rcv_skb").return
{
}

probe dummy_socket_sock_rcv_skb__return
{
	ctracer__method_hook(1, 0xb70655, $sk, 80);
}

probe dummy_unix_stream_connect = kernel.function("dummy_unix_stream_connect")
{
}

probe dummy_unix_stream_connect
{
	ctracer__method_hook(0, 0xb701af, $newsk, 80);
}

probe dummy_unix_stream_connect__return = kernel.function("dummy_unix_stream_connect").return
{
}

probe dummy_unix_stream_connect__return
{
	ctracer__method_hook(1, 0xb701af, $newsk, 80);
}

probe dummy_netlink_send = kernel.function("dummy_netlink_send")
{
}

probe dummy_netlink_send
{
	ctracer__method_hook(0, 0xb700e3, $sk, 80);
}

probe dummy_netlink_send__return = kernel.function("dummy_netlink_send").return
{
}

probe dummy_netlink_send__return
{
	ctracer__method_hook(1, 0xb700e3, $sk, 80);
}

probe selinux_socket_unix_stream_connect = kernel.function("selinux_socket_unix_stream_connect")
{
}

probe selinux_socket_unix_stream_connect
{
	ctracer__method_hook(0, 0xba6037, $newsk, 80);
}

probe selinux_socket_unix_stream_connect__return = kernel.function("selinux_socket_unix_stream_connect").return
{
}

probe selinux_socket_unix_stream_connect__return
{
	ctracer__method_hook(1, 0xba6037, $newsk, 80);
}

probe selinux_netlink_send = kernel.function("selinux_netlink_send")
{
}

probe selinux_netlink_send
{
	ctracer__method_hook(0, 0xba0d77, $sk, 80);
}

probe selinux_netlink_send__return = kernel.function("selinux_netlink_send").return
{
}

probe selinux_netlink_send__return
{
	ctracer__method_hook(1, 0xba0d77, $sk, 80);
}

probe selinux_socket_sock_rcv_skb = kernel.function("selinux_socket_sock_rcv_skb")
{
}

probe selinux_socket_sock_rcv_skb
{
	ctracer__method_hook(0, 0xba018e, $sk, 80);
}

probe selinux_socket_sock_rcv_skb__return = kernel.function("selinux_socket_sock_rcv_skb").return
{
}

probe selinux_socket_sock_rcv_skb__return
{
	ctracer__method_hook(1, 0xba018e, $sk, 80);
}

probe selinux_sk_alloc_security = kernel.function("selinux_sk_alloc_security")
{
}

probe selinux_sk_alloc_security
{
	ctracer__method_hook(0, 0xb9eafd, $sk, 80);
}

probe selinux_sk_alloc_security__return = kernel.function("selinux_sk_alloc_security").return
{
}

probe selinux_sk_alloc_security__return
{
	ctracer__method_hook(1, 0xb9eafd, $sk, 80);
}

probe selinux_sk_clone_security = kernel.function("selinux_sk_clone_security")
{
}

probe selinux_sk_clone_security
{
	ctracer__method_hook(0, 0xb9e837, $newsk, 80);
}

probe selinux_sk_clone_security__return = kernel.function("selinux_sk_clone_security").return
{
}

probe selinux_sk_clone_security__return
{
	ctracer__method_hook(1, 0xb9e837, $newsk, 80);
}

probe selinux_sock_graft = kernel.function("selinux_sock_graft")
{
}

probe selinux_sock_graft
{
	ctracer__method_hook(0, 0xb9e7c1, $sk, 80);
}

probe selinux_sock_graft__return = kernel.function("selinux_sock_graft").return
{
}

probe selinux_sock_graft__return
{
	ctracer__method_hook(1, 0xb9e7c1, $sk, 80);
}

probe selinux_inet_conn_request = kernel.function("selinux_inet_conn_request")
{
}

probe selinux_inet_conn_request
{
	ctracer__method_hook(0, 0xb9e72e, $sk, 80);
}

probe selinux_inet_conn_request__return = kernel.function("selinux_inet_conn_request").return
{
}

probe selinux_inet_conn_request__return
{
	ctracer__method_hook(1, 0xb9e72e, $sk, 80);
}

probe selinux_inet_csk_clone = kernel.function("selinux_inet_csk_clone")
{
}

probe selinux_inet_csk_clone
{
	ctracer__method_hook(0, 0xb9e6dd, $newsk, 80);
}

probe selinux_inet_csk_clone__return = kernel.function("selinux_inet_csk_clone").return
{
}

probe selinux_inet_csk_clone__return
{
	ctracer__method_hook(1, 0xb9e6dd, $newsk, 80);
}

probe selinux_inet_conn_established = kernel.function("selinux_inet_conn_established")
{
}

probe selinux_inet_conn_established
{
	ctracer__method_hook(0, 0xb9e691, $sk, 80);
}

probe selinux_inet_conn_established__return = kernel.function("selinux_inet_conn_established").return
{
}

probe selinux_inet_conn_established__return
{
	ctracer__method_hook(1, 0xb9e691, $sk, 80);
}

probe selinux_sk_free_security = kernel.function("selinux_sk_free_security")
{
}

probe selinux_sk_free_security
{
	ctracer__method_hook(0, 0xb9e46f, $sk, 80);
}

probe selinux_sk_free_security__return = kernel.function("selinux_sk_free_security").return
{
}

probe selinux_sk_free_security__return
{
	ctracer__method_hook(1, 0xb9e46f, $sk, 80);
}

probe selinux_sk_getsecid = kernel.function("selinux_sk_getsecid")
{
}

probe selinux_sk_getsecid
{
	ctracer__method_hook(0, 0xb9dd69, $sk, 80);
}

probe selinux_sk_getsecid__return = kernel.function("selinux_sk_getsecid").return
{
}

probe selinux_sk_getsecid__return
{
	ctracer__method_hook(1, 0xb9dd69, $sk, 80);
}

probe selinux_netlbl_sock_graft = kernel.function("selinux_netlbl_sock_graft")
{
}

probe selinux_netlbl_sock_graft
{
	ctracer__method_hook(0, 0xbed9e0, $sk, 80);
}

probe selinux_netlbl_sock_graft__return = kernel.function("selinux_netlbl_sock_graft").return
{
}

probe selinux_netlbl_sock_graft__return
{
	ctracer__method_hook(1, 0xbed9e0, $sk, 80);
}

probe selinux_netlbl_sock_setsid = kernel.function("selinux_netlbl_sock_setsid")
{
}

probe selinux_netlbl_sock_setsid
{
	ctracer__method_hook(0, 0xbed659, $sk, 80);
}

probe selinux_netlbl_sock_setsid__return = kernel.function("selinux_netlbl_sock_setsid").return
{
}

probe selinux_netlbl_sock_setsid__return
{
	ctracer__method_hook(1, 0xbed659, $sk, 80);
}

probe cn_queue_alloc_dev = kernel.function("cn_queue_alloc_dev")
{
}

probe cn_queue_alloc_dev
{
	ctracer__method_hook(0, 0x12cdb5b, $nls, 80);
}

probe cn_queue_alloc_dev__return = kernel.function("cn_queue_alloc_dev").return
{
}

probe cn_queue_alloc_dev__return
{
	ctracer__method_hook(1, 0x12cdb5b, $nls, 80);
}

probe cn_input = kernel.function("cn_input")
{
}

probe cn_input
{
	ctracer__method_hook(0, 0x12dcdf7, $sk, 80);
}

probe cn_input__return = kernel.function("cn_input").return
{
}

probe cn_input__return
{
	ctracer__method_hook(1, 0x12dcdf7, $sk, 80);
}

probe __sock_recv_timestamp = kernel.function("__sock_recv_timestamp")
{
}

probe __sock_recv_timestamp
{
	ctracer__method_hook(0, 0x16cad2b, $sk, 80);
}

probe __sock_recv_timestamp__return = kernel.function("__sock_recv_timestamp").return
{
}

probe __sock_recv_timestamp__return
{
	ctracer__method_hook(1, 0x16cad2b, $sk, 80);
}

probe sock_queue_rcv_skb = kernel.function("sock_queue_rcv_skb")
{
}

probe sock_queue_rcv_skb
{
	ctracer__method_hook(0, 0x16e27da, $sk, 80);
}

probe sock_queue_rcv_skb__return = kernel.function("sock_queue_rcv_skb").return
{
}

probe sock_queue_rcv_skb__return
{
	ctracer__method_hook(1, 0x16e27da, $sk, 80);
}

probe sk_receive_skb = kernel.function("sk_receive_skb")
{
}

probe sk_receive_skb
{
	ctracer__method_hook(0, 0x16e24c0, $sk, 80);
}

probe sk_receive_skb__return = kernel.function("sk_receive_skb").return
{
}

probe sk_receive_skb__return
{
	ctracer__method_hook(1, 0x16e24c0, $sk, 80);
}

probe __sk_dst_check = kernel.function("__sk_dst_check")
{
}

probe __sk_dst_check
{
	ctracer__method_hook(0, 0x16e2391, $sk, 80);
}

probe __sk_dst_check__return = kernel.function("__sk_dst_check").return
{
}

probe __sk_dst_check__return
{
	ctracer__method_hook(1, 0x16e2391, $sk, 80);
}

probe sock_wmalloc = kernel.function("sock_wmalloc")
{
}

probe sock_wmalloc
{
	ctracer__method_hook(0, 0x16e2268, $sk, 80);
}

probe sock_wmalloc__return = kernel.function("sock_wmalloc").return
{
}

probe sock_wmalloc__return
{
	ctracer__method_hook(1, 0x16e2268, $sk, 80);
}

probe sock_def_write_space = kernel.function("sock_def_write_space")
{
}

probe sock_def_write_space
{
	ctracer__method_hook(0, 0x16e21ed, $sk, 80);
}

probe sock_def_write_space__return = kernel.function("sock_def_write_space").return
{
}

probe sock_def_write_space__return
{
	ctracer__method_hook(1, 0x16e21ed, $sk, 80);
}

probe sock_def_readable = kernel.function("sock_def_readable")
{
}

probe sock_def_readable
{
	ctracer__method_hook(0, 0x16e2144, $sk, 80);
}

probe sock_def_readable__return = kernel.function("sock_def_readable").return
{
}

probe sock_def_readable__return
{
	ctracer__method_hook(1, 0x16e2144, $sk, 80);
}

probe sock_def_error_report = kernel.function("sock_def_error_report")
{
}

probe sock_def_error_report
{
	ctracer__method_hook(0, 0x16e20c9, $sk, 80);
}

probe sock_def_error_report__return = kernel.function("sock_def_error_report").return
{
}

probe sock_def_error_report__return
{
	ctracer__method_hook(1, 0x16e20c9, $sk, 80);
}

probe sock_kmalloc = kernel.function("sock_kmalloc")
{
}

probe sock_kmalloc
{
	ctracer__method_hook(0, 0x16e1404, $sk, 80);
}

probe sock_kmalloc__return = kernel.function("sock_kmalloc").return
{
}

probe sock_kmalloc__return
{
	ctracer__method_hook(1, 0x16e1404, $sk, 80);
}

probe sock_get_timestamp = kernel.function("sock_get_timestamp")
{
}

probe sock_get_timestamp
{
	ctracer__method_hook(0, 0x16e1364, $sk, 80);
}

probe sock_get_timestamp__return = kernel.function("sock_get_timestamp").return
{
}

probe sock_get_timestamp__return
{
	ctracer__method_hook(1, 0x16e1364, $sk, 80);
}

probe sock_i_uid = kernel.function("sock_i_uid")
{
}

probe sock_i_uid
{
	ctracer__method_hook(0, 0x16e0d88, $sk, 80);
}

probe sock_i_uid__return = kernel.function("sock_i_uid").return
{
}

probe sock_i_uid__return
{
	ctracer__method_hook(1, 0x16e0d88, $sk, 80);
}

probe sock_init_data = kernel.function("sock_init_data")
{
}

probe sock_init_data
{
	ctracer__method_hook(0, 0x16e0c68, $sk, 80);
}

probe sock_init_data__return = kernel.function("sock_init_data").return
{
}

probe sock_init_data__return
{
	ctracer__method_hook(1, 0x16e0c68, $sk, 80);
}

probe sk_wait_data = kernel.function("sk_wait_data")
{
}

probe sk_wait_data
{
	ctracer__method_hook(0, 0x16e0754, $sk, 80);
}

probe sk_wait_data__return = kernel.function("sk_wait_data").return
{
}

probe sk_wait_data__return
{
	ctracer__method_hook(1, 0x16e0754, $sk, 80);
}

probe sock_def_wakeup = kernel.function("sock_def_wakeup")
{
}

probe sock_def_wakeup
{
	ctracer__method_hook(0, 0x16e06db, $sk, 80);
}

probe sock_def_wakeup__return = kernel.function("sock_def_wakeup").return
{
}

probe sock_def_wakeup__return
{
	ctracer__method_hook(1, 0x16e06db, $sk, 80);
}

probe sock_i_ino = kernel.function("sock_i_ino")
{
}

probe sock_i_ino
{
	ctracer__method_hook(0, 0x16e0655, $sk, 80);
}

probe sock_i_ino__return = kernel.function("sock_i_ino").return
{
}

probe sock_i_ino__return
{
	ctracer__method_hook(1, 0x16e0655, $sk, 80);
}

probe sk_common_release = kernel.function("sk_common_release")
{
}

probe sk_common_release
{
	ctracer__method_hook(0, 0x16e01c8, $sk, 80);
}

probe sk_common_release__return = kernel.function("sk_common_release").return
{
}

probe sk_common_release__return
{
	ctracer__method_hook(1, 0x16e01c8, $sk, 80);
}

probe sk_free = kernel.function("sk_free")
{
}

probe sk_free
{
	ctracer__method_hook(0, 0x16dff70, $sk, 80);
}

probe sk_free__return = kernel.function("sk_free").return
{
}

probe sk_free__return
{
	ctracer__method_hook(1, 0x16dff70, $sk, 80);
}

probe sk_dst_check = kernel.function("sk_dst_check")
{
}

probe sk_dst_check
{
	ctracer__method_hook(0, 0x16dfd5a, $sk, 80);
}

probe sk_dst_check__return = kernel.function("sk_dst_check").return
{
}

probe sk_dst_check__return
{
	ctracer__method_hook(1, 0x16dfd5a, $sk, 80);
}

probe sk_setup_caps = kernel.function("sk_setup_caps")
{
}

probe sk_setup_caps
{
	ctracer__method_hook(0, 0x16dfc28, $sk, 80);
}

probe sk_setup_caps__return = kernel.function("sk_setup_caps").return
{
}

probe sk_setup_caps__return
{
	ctracer__method_hook(1, 0x16dfc28, $sk, 80);
}

probe sock_alloc_send_skb = kernel.function("sock_alloc_send_skb")
{
}

probe sock_alloc_send_skb
{
	ctracer__method_hook(0, 0x16df71a, $sk, 80);
}

probe sock_alloc_send_skb__return = kernel.function("sock_alloc_send_skb").return
{
}

probe sock_alloc_send_skb__return
{
	ctracer__method_hook(1, 0x16df71a, $sk, 80);
}

probe sock_rmalloc = kernel.function("sock_rmalloc")
{
}

probe sock_rmalloc
{
	ctracer__method_hook(0, 0x16df4a2, $sk, 80);
}

probe sock_rmalloc__return = kernel.function("sock_rmalloc").return
{
}

probe sock_rmalloc__return
{
	ctracer__method_hook(1, 0x16df4a2, $sk, 80);
}

probe sk_send_sigurg = kernel.function("sk_send_sigurg")
{
}

probe sk_send_sigurg
{
	ctracer__method_hook(0, 0x16df2f0, $sk, 80);
}

probe sk_send_sigurg__return = kernel.function("sk_send_sigurg").return
{
}

probe sk_send_sigurg__return
{
	ctracer__method_hook(1, 0x16df2f0, $sk, 80);
}

probe sk_reset_timer = kernel.function("sk_reset_timer")
{
}

probe sk_reset_timer
{
	ctracer__method_hook(0, 0x16df230, $sk, 80);
}

probe sk_reset_timer__return = kernel.function("sk_reset_timer").return
{
}

probe sk_reset_timer__return
{
	ctracer__method_hook(1, 0x16df230, $sk, 80);
}

probe sk_stop_timer = kernel.function("sk_stop_timer")
{
}

probe sk_stop_timer
{
	ctracer__method_hook(0, 0x16df1ac, $sk, 80);
}

probe sk_stop_timer__return = kernel.function("sk_stop_timer").return
{
}

probe sk_stop_timer__return
{
	ctracer__method_hook(1, 0x16df1ac, $sk, 80);
}

probe lock_sock_nested = kernel.function("lock_sock_nested")
{
}

probe lock_sock_nested
{
	ctracer__method_hook(0, 0x16df081, $sk, 80);
}

probe lock_sock_nested__return = kernel.function("lock_sock_nested").return
{
}

probe lock_sock_nested__return
{
	ctracer__method_hook(1, 0x16df081, $sk, 80);
}

probe release_sock = kernel.function("release_sock")
{
}

probe release_sock
{
	ctracer__method_hook(0, 0x16defa7, $sk, 80);
}

probe release_sock__return = kernel.function("release_sock").return
{
}

probe release_sock__return
{
	ctracer__method_hook(1, 0x16defa7, $sk, 80);
}

probe sock_get_timestampns = kernel.function("sock_get_timestampns")
{
}

probe sock_get_timestampns
{
	ctracer__method_hook(0, 0x16deed4, $sk, 80);
}

probe sock_get_timestampns__return = kernel.function("sock_get_timestampns").return
{
}

probe sock_get_timestampns__return
{
	ctracer__method_hook(1, 0x16deed4, $sk, 80);
}

probe sock_enable_timestamp = kernel.function("sock_enable_timestamp")
{
}

probe sock_enable_timestamp
{
	ctracer__method_hook(0, 0x16dee13, $sk, 80);
}

probe sock_enable_timestamp__return = kernel.function("sock_enable_timestamp").return
{
}

probe sock_enable_timestamp__return
{
	ctracer__method_hook(1, 0x16dee13, $sk, 80);
}

probe sock_kfree_s = kernel.function("sock_kfree_s")
{
}

probe sock_kfree_s
{
	ctracer__method_hook(0, 0x16ded62, $sk, 80);
}

probe sock_kfree_s__return = kernel.function("sock_kfree_s").return
{
}

probe sock_kfree_s__return
{
	ctracer__method_hook(1, 0x16ded62, $sk, 80);
}

probe sock_def_destruct = kernel.function("sock_def_destruct")
{
}

probe sock_def_destruct
{
	ctracer__method_hook(0, 0x16ded32, $sk, 80);
}

probe sock_def_destruct__return = kernel.function("sock_def_destruct").return
{
}

probe sock_def_destruct__return
{
	ctracer__method_hook(1, 0x16ded32, $sk, 80);
}

probe skb_append_datato_frags = kernel.function("skb_append_datato_frags")
{
}

probe skb_append_datato_frags
{
	ctracer__method_hook(0, 0x1706807, $sk, 80);
}

probe skb_append_datato_frags__return = kernel.function("skb_append_datato_frags").return
{
}

probe skb_append_datato_frags__return
{
	ctracer__method_hook(1, 0x1706807, $sk, 80);
}

probe skb_recv_datagram = kernel.function("skb_recv_datagram")
{
}

probe skb_recv_datagram
{
	ctracer__method_hook(0, 0x1726035, $sk, 80);
}

probe skb_recv_datagram__return = kernel.function("skb_recv_datagram").return
{
}

probe skb_recv_datagram__return
{
	ctracer__method_hook(1, 0x1726035, $sk, 80);
}

probe skb_free_datagram = kernel.function("skb_free_datagram")
{
}

probe skb_free_datagram
{
	ctracer__method_hook(0, 0x1725d8c, $sk, 80);
}

probe skb_free_datagram__return = kernel.function("skb_free_datagram").return
{
}

probe skb_free_datagram__return
{
	ctracer__method_hook(1, 0x1725d8c, $sk, 80);
}

probe skb_kill_datagram = kernel.function("skb_kill_datagram")
{
}

probe skb_kill_datagram
{
	ctracer__method_hook(0, 0x1725caf, $sk, 80);
}

probe skb_kill_datagram__return = kernel.function("skb_kill_datagram").return
{
}

probe skb_kill_datagram__return
{
	ctracer__method_hook(1, 0x1725caf, $sk, 80);
}

probe sk_stream_wait_close = kernel.function("sk_stream_wait_close")
{
}

probe sk_stream_wait_close
{
	ctracer__method_hook(0, 0x1735ae4, $sk, 80);
}

probe sk_stream_wait_close__return = kernel.function("sk_stream_wait_close").return
{
}

probe sk_stream_wait_close__return
{
	ctracer__method_hook(1, 0x1735ae4, $sk, 80);
}

probe sk_stream_wait_connect = kernel.function("sk_stream_wait_connect")
{
}

probe sk_stream_wait_connect
{
	ctracer__method_hook(0, 0x17358ba, $sk, 80);
}

probe sk_stream_wait_connect__return = kernel.function("sk_stream_wait_connect").return
{
}

probe sk_stream_wait_connect__return
{
	ctracer__method_hook(1, 0x17358ba, $sk, 80);
}

probe sk_stream_kill_queues = kernel.function("sk_stream_kill_queues")
{
}

probe sk_stream_kill_queues
{
	ctracer__method_hook(0, 0x17357c2, $sk, 80);
}

probe sk_stream_kill_queues__return = kernel.function("sk_stream_kill_queues").return
{
}

probe sk_stream_kill_queues__return
{
	ctracer__method_hook(1, 0x17357c2, $sk, 80);
}

probe sk_stream_mem_schedule = kernel.function("sk_stream_mem_schedule")
{
}

probe sk_stream_mem_schedule
{
	ctracer__method_hook(0, 0x1735651, $sk, 80);
}

probe sk_stream_mem_schedule__return = kernel.function("sk_stream_mem_schedule").return
{
}

probe sk_stream_mem_schedule__return
{
	ctracer__method_hook(1, 0x1735651, $sk, 80);
}

probe sk_stream_wait_memory = kernel.function("sk_stream_wait_memory")
{
}

probe sk_stream_wait_memory
{
	ctracer__method_hook(0, 0x17352d7, $sk, 80);
}

probe sk_stream_wait_memory__return = kernel.function("sk_stream_wait_memory").return
{
}

probe sk_stream_wait_memory__return
{
	ctracer__method_hook(1, 0x17352d7, $sk, 80);
}

probe sk_stream_write_space = kernel.function("sk_stream_write_space")
{
}

probe sk_stream_write_space
{
	ctracer__method_hook(0, 0x173511f, $sk, 80);
}

probe sk_stream_write_space__return = kernel.function("sk_stream_write_space").return
{
}

probe sk_stream_write_space__return
{
	ctracer__method_hook(1, 0x173511f, $sk, 80);
}

probe sk_stream_error = kernel.function("sk_stream_error")
{
}

probe sk_stream_error
{
	ctracer__method_hook(0, 0x1734fa8, $sk, 80);
}

probe sk_stream_error__return = kernel.function("sk_stream_error").return
{
}

probe sk_stream_error__return
{
	ctracer__method_hook(1, 0x1734fa8, $sk, 80);
}

probe __sk_stream_mem_reclaim = kernel.function("__sk_stream_mem_reclaim")
{
}

probe __sk_stream_mem_reclaim
{
	ctracer__method_hook(0, 0x1734f0d, $sk, 80);
}

probe __sk_stream_mem_reclaim__return = kernel.function("__sk_stream_mem_reclaim").return
{
}

probe __sk_stream_mem_reclaim__return
{
	ctracer__method_hook(1, 0x1734f0d, $sk, 80);
}

probe rtnetlink_rcv = kernel.function("rtnetlink_rcv")
{
}

probe rtnetlink_rcv
{
	ctracer__method_hook(0, 0x17ce6b1, $sk, 80);
}

probe rtnetlink_rcv__return = kernel.function("rtnetlink_rcv").return
{
}

probe rtnetlink_rcv__return
{
	ctracer__method_hook(1, 0x17ce6b1, $sk, 80);
}

probe sk_attach_filter = kernel.function("sk_attach_filter")
{
}

probe sk_attach_filter
{
	ctracer__method_hook(0, 0x17fc5ba, $sk, 80);
}

probe sk_attach_filter__return = kernel.function("sk_attach_filter").return
{
}

probe sk_attach_filter__return
{
	ctracer__method_hook(1, 0x17fc5ba, $sk, 80);
}

probe compat_sock_get_timestamp = kernel.function("compat_sock_get_timestamp")
{
}

probe compat_sock_get_timestamp
{
	ctracer__method_hook(0, 0x1853669, $sk, 80);
}

probe compat_sock_get_timestamp__return = kernel.function("compat_sock_get_timestamp").return
{
}

probe compat_sock_get_timestamp__return
{
	ctracer__method_hook(1, 0x1853669, $sk, 80);
}

probe cmsghdr_from_user_compat_to_kern = kernel.function("cmsghdr_from_user_compat_to_kern")
{
}

probe cmsghdr_from_user_compat_to_kern
{
	ctracer__method_hook(0, 0x185344f, $sk, 80);
}

probe cmsghdr_from_user_compat_to_kern__return = kernel.function("cmsghdr_from_user_compat_to_kern").return
{
}

probe cmsghdr_from_user_compat_to_kern__return
{
	ctracer__method_hook(1, 0x185344f, $sk, 80);
}

probe compat_sock_get_timestampns = kernel.function("compat_sock_get_timestampns")
{
}

probe compat_sock_get_timestampns
{
	ctracer__method_hook(0, 0x1851c3f, $sk, 80);
}

probe compat_sock_get_timestampns__return = kernel.function("compat_sock_get_timestampns").return
{
}

probe compat_sock_get_timestampns__return
{
	ctracer__method_hook(1, 0x1851c3f, $sk, 80);
}

probe netlink_dump_start = kernel.function("netlink_dump_start")
{
}

probe netlink_dump_start
{
	ctracer__method_hook(0, 0x1917ca6, $ssk, 80);
}

probe netlink_dump_start__return = kernel.function("netlink_dump_start").return
{
}

probe netlink_dump_start__return
{
	ctracer__method_hook(1, 0x1917ca6, $ssk, 80);
}

probe netlink_detachskb = kernel.function("netlink_detachskb")
{
}

probe netlink_detachskb
{
	ctracer__method_hook(0, 0x1917c19, $sk, 80);
}

probe netlink_detachskb__return = kernel.function("netlink_detachskb").return
{
}

probe netlink_detachskb__return
{
	ctracer__method_hook(1, 0x1917c19, $sk, 80);
}

probe netlink_change_ngroups = kernel.function("netlink_change_ngroups")
{
}

probe netlink_change_ngroups
{
	ctracer__method_hook(0, 0x19173af, $sk, 80);
}

probe netlink_change_ngroups__return = kernel.function("netlink_change_ngroups").return
{
}

probe netlink_change_ngroups__return
{
	ctracer__method_hook(1, 0x19173af, $sk, 80);
}

probe netlink_clear_multicast_users = kernel.function("netlink_clear_multicast_users")
{
}

probe netlink_clear_multicast_users
{
	ctracer__method_hook(0, 0x1916a74, $ksk, 80);
}

probe netlink_clear_multicast_users__return = kernel.function("netlink_clear_multicast_users").return
{
}

probe netlink_clear_multicast_users__return
{
	ctracer__method_hook(1, 0x1916a74, $ksk, 80);
}

probe netlink_data_ready = kernel.function("netlink_data_ready")
{
}

probe netlink_data_ready
{
	ctracer__method_hook(0, 0x19169c0, $sk, 80);
}

probe netlink_data_ready__return = kernel.function("netlink_data_ready").return
{
}

probe netlink_data_ready__return
{
	ctracer__method_hook(1, 0x19169c0, $sk, 80);
}

probe netlink_has_listeners = kernel.function("netlink_has_listeners")
{
}

probe netlink_has_listeners
{
	ctracer__method_hook(0, 0x19162f9, $sk, 80);
}

probe netlink_has_listeners__return = kernel.function("netlink_has_listeners").return
{
}

probe netlink_has_listeners__return
{
	ctracer__method_hook(1, 0x19162f9, $sk, 80);
}

probe netlink_sock_destruct = kernel.function("netlink_sock_destruct")
{
}

probe netlink_sock_destruct
{
	ctracer__method_hook(0, 0x1916276, $sk, 80);
}

probe netlink_sock_destruct__return = kernel.function("netlink_sock_destruct").return
{
}

probe netlink_sock_destruct__return
{
	ctracer__method_hook(1, 0x1916276, $sk, 80);
}

probe netlink_run_queue = kernel.function("netlink_run_queue")
{
}

probe netlink_run_queue
{
	ctracer__method_hook(0, 0x19161bb, $sk, 80);
}

probe netlink_run_queue__return = kernel.function("netlink_run_queue").return
{
}

probe netlink_run_queue__return
{
	ctracer__method_hook(1, 0x19161bb, $sk, 80);
}

probe netlink_set_err = kernel.function("netlink_set_err")
{
}

probe netlink_set_err
{
	ctracer__method_hook(0, 0x1915ef3, $ssk, 80);
}

probe netlink_set_err__return = kernel.function("netlink_set_err").return
{
}

probe netlink_set_err__return
{
	ctracer__method_hook(1, 0x1915ef3, $ssk, 80);
}

probe nlmsg_notify = kernel.function("nlmsg_notify")
{
}

probe nlmsg_notify
{
	ctracer__method_hook(0, 0x1915ac5, $sk, 80);
}

probe nlmsg_notify__return = kernel.function("nlmsg_notify").return
{
}

probe nlmsg_notify__return
{
	ctracer__method_hook(1, 0x1915ac5, $sk, 80);
}

probe netlink_unicast = kernel.function("netlink_unicast")
{
}

probe netlink_unicast
{
	ctracer__method_hook(0, 0x191545a, $ssk, 80);
}

probe netlink_unicast__return = kernel.function("netlink_unicast").return
{
}

probe netlink_unicast__return
{
	ctracer__method_hook(1, 0x191545a, $ssk, 80);
}

probe netlink_attachskb = kernel.function("netlink_attachskb")
{
}

probe netlink_attachskb
{
	ctracer__method_hook(0, 0x1914ff9, $sk, 80);
}

probe netlink_attachskb__return = kernel.function("netlink_attachskb").return
{
}

probe netlink_attachskb__return
{
	ctracer__method_hook(1, 0x1914ff9, $sk, 80);
}

probe netlink_broadcast = kernel.function("netlink_broadcast")
{
}

probe netlink_broadcast
{
	ctracer__method_hook(0, 0x1914c02, $ssk, 80);
}

probe netlink_broadcast__return = kernel.function("netlink_broadcast").return
{
}

probe netlink_broadcast__return
{
	ctracer__method_hook(1, 0x1914c02, $ssk, 80);
}

probe netlink_insert = kernel.function("netlink_insert")
{
}

probe netlink_insert
{
	ctracer__method_hook(0, 0x19147dc, $sk, 80);
}

probe netlink_insert__return = kernel.function("netlink_insert").return
{
}

probe netlink_insert__return
{
	ctracer__method_hook(1, 0x19147dc, $sk, 80);
}

probe netlink_sendskb = kernel.function("netlink_sendskb")
{
}

probe netlink_sendskb
{
	ctracer__method_hook(0, 0x1914518, $sk, 80);
}

probe netlink_sendskb__return = kernel.function("netlink_sendskb").return
{
}

probe netlink_sendskb__return
{
	ctracer__method_hook(1, 0x1914518, $sk, 80);
}

probe netlink_realloc_groups = kernel.function("netlink_realloc_groups")
{
}

probe netlink_realloc_groups
{
	ctracer__method_hook(0, 0x1914452, $sk, 80);
}

probe netlink_realloc_groups__return = kernel.function("netlink_realloc_groups").return
{
}

probe netlink_realloc_groups__return
{
	ctracer__method_hook(1, 0x1914452, $sk, 80);
}

probe netlink_dump = kernel.function("netlink_dump")
{
}

probe netlink_dump
{
	ctracer__method_hook(0, 0x19140ce, $sk, 80);
}

probe netlink_dump__return = kernel.function("netlink_dump").return
{
}

probe netlink_dump__return
{
	ctracer__method_hook(1, 0x19140ce, $sk, 80);
}

probe netlink_overrun = kernel.function("netlink_overrun")
{
}

probe netlink_overrun
{
	ctracer__method_hook(0, 0x191398f, $sk, 80);
}

probe netlink_overrun__return = kernel.function("netlink_overrun").return
{
}

probe netlink_overrun__return
{
	ctracer__method_hook(1, 0x191398f, $sk, 80);
}

probe netlink_update_subscriptions = kernel.function("netlink_update_subscriptions")
{
}

probe netlink_update_subscriptions
{
	ctracer__method_hook(0, 0x19138a4, $sk, 80);
}

probe netlink_update_subscriptions__return = kernel.function("netlink_update_subscriptions").return
{
}

probe netlink_update_subscriptions__return
{
	ctracer__method_hook(1, 0x19138a4, $sk, 80);
}

probe netlink_update_listeners = kernel.function("netlink_update_listeners")
{
}

probe netlink_update_listeners
{
	ctracer__method_hook(0, 0x19137f4, $sk, 80);
}

probe netlink_update_listeners__return = kernel.function("netlink_update_listeners").return
{
}

probe netlink_update_listeners__return
{
	ctracer__method_hook(1, 0x19137f4, $sk, 80);
}

probe genl_rcv = kernel.function("genl_rcv")
{
}

probe genl_rcv
{
	ctracer__method_hook(0, 0x192fedf, $sk, 80);
}

probe genl_rcv__return = kernel.function("genl_rcv").return
{
}

probe genl_rcv__return
{
	ctracer__method_hook(1, 0x192fedf, $sk, 80);
}

probe nf_setsockopt = kernel.function("nf_setsockopt")
{
}

probe nf_setsockopt
{
	ctracer__method_hook(0, 0x196e03c, $sk, 80);
}

probe nf_setsockopt__return = kernel.function("nf_setsockopt").return
{
}

probe nf_setsockopt__return
{
	ctracer__method_hook(1, 0x196e03c, $sk, 80);
}

probe nf_getsockopt = kernel.function("nf_getsockopt")
{
}

probe nf_getsockopt
{
	ctracer__method_hook(0, 0x196dfce, $sk, 80);
}

probe nf_getsockopt__return = kernel.function("nf_getsockopt").return
{
}

probe nf_getsockopt__return
{
	ctracer__method_hook(1, 0x196dfce, $sk, 80);
}

probe nf_sockopt = kernel.function("nf_sockopt")
{
}

probe nf_sockopt
{
	ctracer__method_hook(0, 0x196de5f, $sk, 80);
}

probe nf_sockopt__return = kernel.function("nf_sockopt").return
{
}

probe nf_sockopt__return
{
	ctracer__method_hook(1, 0x196de5f, $sk, 80);
}

probe compat_nf_setsockopt = kernel.function("compat_nf_setsockopt")
{
}

probe compat_nf_setsockopt
{
	ctracer__method_hook(0, 0x196ddf0, $sk, 80);
}

probe compat_nf_setsockopt__return = kernel.function("compat_nf_setsockopt").return
{
}

probe compat_nf_setsockopt__return
{
	ctracer__method_hook(1, 0x196ddf0, $sk, 80);
}

probe compat_nf_getsockopt = kernel.function("compat_nf_getsockopt")
{
}

probe compat_nf_getsockopt
{
	ctracer__method_hook(0, 0x196dd82, $sk, 80);
}

probe compat_nf_getsockopt__return = kernel.function("compat_nf_getsockopt").return
{
}

probe compat_nf_getsockopt__return
{
	ctracer__method_hook(1, 0x196dd82, $sk, 80);
}

probe compat_nf_sockopt = kernel.function("compat_nf_sockopt")
{
}

probe compat_nf_sockopt
{
	ctracer__method_hook(0, 0x196dc0d, $sk, 80);
}

probe compat_nf_sockopt__return = kernel.function("compat_nf_sockopt").return
{
}

probe compat_nf_sockopt__return
{
	ctracer__method_hook(1, 0x196dc0d, $sk, 80);
}

probe ip_route_output_flow = kernel.function("ip_route_output_flow")
{
}

probe ip_route_output_flow
{
	ctracer__method_hook(0, 0x1983de4, $sk, 80);
}

probe ip_route_output_flow__return = kernel.function("ip_route_output_flow").return
{
}

probe ip_route_output_flow__return
{
	ctracer__method_hook(1, 0x1983de4, $sk, 80);
}

probe ip_build_and_send_pkt = kernel.function("ip_build_and_send_pkt")
{
}

probe ip_build_and_send_pkt
{
	ctracer__method_hook(0, 0x19fe053, $sk, 80);
}

probe ip_build_and_send_pkt__return = kernel.function("ip_build_and_send_pkt").return
{
}

probe ip_build_and_send_pkt__return
{
	ctracer__method_hook(1, 0x19fe053, $sk, 80);
}

probe ip_flush_pending_frames = kernel.function("ip_flush_pending_frames")
{
}

probe ip_flush_pending_frames
{
	ctracer__method_hook(0, 0x19fdebb, $sk, 80);
}

probe ip_flush_pending_frames__return = kernel.function("ip_flush_pending_frames").return
{
}

probe ip_flush_pending_frames__return
{
	ctracer__method_hook(1, 0x19fdebb, $sk, 80);
}

probe ip_send_reply = kernel.function("ip_send_reply")
{
}

probe ip_send_reply
{
	ctracer__method_hook(0, 0x19fd76a, $sk, 80);
}

probe ip_send_reply__return = kernel.function("ip_send_reply").return
{
}

probe ip_send_reply__return
{
	ctracer__method_hook(1, 0x19fd76a, $sk, 80);
}

probe ip_append_page = kernel.function("ip_append_page")
{
}

probe ip_append_page
{
	ctracer__method_hook(0, 0x19fcfda, $sk, 80);
}

probe ip_append_page__return = kernel.function("ip_append_page").return
{
}

probe ip_append_page__return
{
	ctracer__method_hook(1, 0x19fcfda, $sk, 80);
}

probe ip_append_data = kernel.function("ip_append_data")
{
}

probe ip_append_data
{
	ctracer__method_hook(0, 0x19fae02, $sk, 80);
}

probe ip_append_data__return = kernel.function("ip_append_data").return
{
}

probe ip_append_data__return
{
	ctracer__method_hook(1, 0x19fae02, $sk, 80);
}

probe ip_push_pending_frames = kernel.function("ip_push_pending_frames")
{
}

probe ip_push_pending_frames
{
	ctracer__method_hook(0, 0x19fa8cb, $sk, 80);
}

probe ip_push_pending_frames__return = kernel.function("ip_push_pending_frames").return
{
}

probe ip_push_pending_frames__return
{
	ctracer__method_hook(1, 0x19fa8cb, $sk, 80);
}

probe ip_icmp_error = kernel.function("ip_icmp_error")
{
}

probe ip_icmp_error
{
	ctracer__method_hook(0, 0x1a12478, $sk, 80);
}

probe ip_icmp_error__return = kernel.function("ip_icmp_error").return
{
}

probe ip_icmp_error__return
{
	ctracer__method_hook(1, 0x1a12478, $sk, 80);
}

probe ip_getsockopt = kernel.function("ip_getsockopt")
{
}

probe ip_getsockopt
{
	ctracer__method_hook(0, 0x1a12317, $sk, 80);
}

probe ip_getsockopt__return = kernel.function("ip_getsockopt").return
{
}

probe ip_getsockopt__return
{
	ctracer__method_hook(1, 0x1a12317, $sk, 80);
}

probe compat_ip_setsockopt = kernel.function("compat_ip_setsockopt")
{
}

probe compat_ip_setsockopt
{
	ctracer__method_hook(0, 0x1a12273, $sk, 80);
}

probe compat_ip_setsockopt__return = kernel.function("compat_ip_setsockopt").return
{
}

probe compat_ip_setsockopt__return
{
	ctracer__method_hook(1, 0x1a12273, $sk, 80);
}

probe ip_setsockopt = kernel.function("ip_setsockopt")
{
}

probe ip_setsockopt
{
	ctracer__method_hook(0, 0x1a121cf, $sk, 80);
}

probe ip_setsockopt__return = kernel.function("ip_setsockopt").return
{
}

probe ip_setsockopt__return
{
	ctracer__method_hook(1, 0x1a121cf, $sk, 80);
}

probe ip_local_error = kernel.function("ip_local_error")
{
}

probe ip_local_error
{
	ctracer__method_hook(0, 0x1a11f5f, $sk, 80);
}

probe ip_local_error__return = kernel.function("ip_local_error").return
{
}

probe ip_local_error__return
{
	ctracer__method_hook(1, 0x1a11f5f, $sk, 80);
}

probe ip_recv_error = kernel.function("ip_recv_error")
{
}

probe ip_recv_error
{
	ctracer__method_hook(0, 0x1a11c5c, $sk, 80);
}

probe ip_recv_error__return = kernel.function("ip_recv_error").return
{
}

probe ip_recv_error__return
{
	ctracer__method_hook(1, 0x1a11c5c, $sk, 80);
}

probe do_ip_setsockopt = kernel.function("do_ip_setsockopt")
{
}

probe do_ip_setsockopt
{
	ctracer__method_hook(0, 0x1a1120b, $sk, 80);
}

probe do_ip_setsockopt__return = kernel.function("do_ip_setsockopt").return
{
}

probe do_ip_setsockopt__return
{
	ctracer__method_hook(1, 0x1a1120b, $sk, 80);
}

probe ip_ra_control = kernel.function("ip_ra_control")
{
}

probe ip_ra_control
{
	ctracer__method_hook(0, 0x1a110cd, $sk, 80);
}

probe ip_ra_control__return = kernel.function("ip_ra_control").return
{
}

probe ip_ra_control__return
{
	ctracer__method_hook(1, 0x1a110cd, $sk, 80);
}

probe compat_ip_getsockopt = kernel.function("compat_ip_getsockopt")
{
}

probe compat_ip_getsockopt
{
	ctracer__method_hook(0, 0x1a10fbc, $sk, 80);
}

probe compat_ip_getsockopt__return = kernel.function("compat_ip_getsockopt").return
{
}

probe compat_ip_getsockopt__return
{
	ctracer__method_hook(1, 0x1a10fbc, $sk, 80);
}

probe do_ip_getsockopt = kernel.function("do_ip_getsockopt")
{
}

probe do_ip_getsockopt
{
	ctracer__method_hook(0, 0x1a10ae6, $sk, 80);
}

probe do_ip_getsockopt__return = kernel.function("do_ip_getsockopt").return
{
}

probe do_ip_getsockopt__return
{
	ctracer__method_hook(1, 0x1a10ae6, $sk, 80);
}

probe inet_hash_connect = kernel.function("inet_hash_connect")
{
}

probe inet_hash_connect
{
	ctracer__method_hook(0, 0x1a22edb, $sk, 80);
}

probe inet_hash_connect__return = kernel.function("inet_hash_connect").return
{
}

probe inet_hash_connect__return
{
	ctracer__method_hook(1, 0x1a22edb, $sk, 80);
}

probe __inet_check_established = kernel.function("__inet_check_established")
{
}

probe __inet_check_established
{
	ctracer__method_hook(0, 0x1a2256c, $sk, 80);
}

probe __inet_check_established__return = kernel.function("__inet_check_established").return
{
}

probe __inet_check_established__return
{
	ctracer__method_hook(1, 0x1a2256c, $sk, 80);
}

probe inet_put_port = kernel.function("inet_put_port")
{
}

probe inet_put_port
{
	ctracer__method_hook(0, 0x1a22486, $sk, 80);
}

probe inet_put_port__return = kernel.function("inet_put_port").return
{
}

probe inet_put_port__return
{
	ctracer__method_hook(1, 0x1a22486, $sk, 80);
}

probe inet_bind_hash = kernel.function("inet_bind_hash")
{
}

probe inet_bind_hash
{
	ctracer__method_hook(0, 0x1a22324, $sk, 80);
}

probe inet_bind_hash__return = kernel.function("inet_bind_hash").return
{
}

probe inet_bind_hash__return
{
	ctracer__method_hook(1, 0x1a22324, $sk, 80);
}

probe __inet_twsk_hashdance = kernel.function("__inet_twsk_hashdance")
{
}

probe __inet_twsk_hashdance
{
	ctracer__method_hook(0, 0x1a33eae, $sk, 80);
}

probe __inet_twsk_hashdance__return = kernel.function("__inet_twsk_hashdance").return
{
}

probe __inet_twsk_hashdance__return
{
	ctracer__method_hook(1, 0x1a33eae, $sk, 80);
}

probe inet_csk_get_port = kernel.function("inet_csk_get_port")
{
}

probe inet_csk_get_port
{
	ctracer__method_hook(0, 0x1a46c61, $sk, 80);
}

probe inet_csk_get_port__return = kernel.function("inet_csk_get_port").return
{
}

probe inet_csk_get_port__return
{
	ctracer__method_hook(1, 0x1a46c61, $sk, 80);
}

probe inet_csk_compat_getsockopt = kernel.function("inet_csk_compat_getsockopt")
{
}

probe inet_csk_compat_getsockopt
{
	ctracer__method_hook(0, 0x1a46b72, $sk, 80);
}

probe inet_csk_compat_getsockopt__return = kernel.function("inet_csk_compat_getsockopt").return
{
}

probe inet_csk_compat_getsockopt__return
{
	ctracer__method_hook(1, 0x1a46b72, $sk, 80);
}

probe inet_csk_listen_stop = kernel.function("inet_csk_listen_stop")
{
}

probe inet_csk_listen_stop
{
	ctracer__method_hook(0, 0x1a4694e, $sk, 80);
}

probe inet_csk_listen_stop__return = kernel.function("inet_csk_listen_stop").return
{
}

probe inet_csk_listen_stop__return
{
	ctracer__method_hook(1, 0x1a4694e, $sk, 80);
}

probe inet_csk_listen_start = kernel.function("inet_csk_listen_start")
{
}

probe inet_csk_listen_start
{
	ctracer__method_hook(0, 0x1a4674f, $sk, 80);
}

probe inet_csk_listen_start__return = kernel.function("inet_csk_listen_start").return
{
}

probe inet_csk_listen_start__return
{
	ctracer__method_hook(1, 0x1a4674f, $sk, 80);
}

probe inet_csk_clone = kernel.function("inet_csk_clone")
{
}

probe inet_csk_clone
{
	ctracer__method_hook(0, 0x1a46622, $sk, 80);
}

probe inet_csk_clone__return = kernel.function("inet_csk_clone").return
{
}

probe inet_csk_clone__return
{
	ctracer__method_hook(1, 0x1a46622, $sk, 80);
}

probe inet_csk_reqsk_queue_prune = kernel.function("inet_csk_reqsk_queue_prune")
{
}

probe inet_csk_reqsk_queue_prune
{
	ctracer__method_hook(0, 0x1a463c9, $parent, 80);
}

probe inet_csk_reqsk_queue_prune__return = kernel.function("inet_csk_reqsk_queue_prune").return
{
}

probe inet_csk_reqsk_queue_prune__return
{
	ctracer__method_hook(1, 0x1a463c9, $parent, 80);
}

probe inet_csk_reqsk_queue_hash_add = kernel.function("inet_csk_reqsk_queue_hash_add")
{
}

probe inet_csk_reqsk_queue_hash_add
{
	ctracer__method_hook(0, 0x1a461aa, $sk, 80);
}

probe inet_csk_reqsk_queue_hash_add__return = kernel.function("inet_csk_reqsk_queue_hash_add").return
{
}

probe inet_csk_reqsk_queue_hash_add__return
{
	ctracer__method_hook(1, 0x1a461aa, $sk, 80);
}

probe inet_csk_clear_xmit_timers = kernel.function("inet_csk_clear_xmit_timers")
{
}

probe inet_csk_clear_xmit_timers
{
	ctracer__method_hook(0, 0x1a4609c, $sk, 80);
}

probe inet_csk_clear_xmit_timers__return = kernel.function("inet_csk_clear_xmit_timers").return
{
}

probe inet_csk_clear_xmit_timers__return
{
	ctracer__method_hook(1, 0x1a4609c, $sk, 80);
}

probe inet_csk_init_xmit_timers = kernel.function("inet_csk_init_xmit_timers")
{
}

probe inet_csk_init_xmit_timers
{
	ctracer__method_hook(0, 0x1a4602e, $sk, 80);
}

probe inet_csk_init_xmit_timers__return = kernel.function("inet_csk_init_xmit_timers").return
{
}

probe inet_csk_init_xmit_timers__return
{
	ctracer__method_hook(1, 0x1a4602e, $sk, 80);
}

probe inet_csk_accept = kernel.function("inet_csk_accept")
{
}

probe inet_csk_accept
{
	ctracer__method_hook(0, 0x1a45d23, $sk, 80);
}

probe inet_csk_accept__return = kernel.function("inet_csk_accept").return
{
}

probe inet_csk_accept__return
{
	ctracer__method_hook(1, 0x1a45d23, $sk, 80);
}

probe inet_csk_addr2sockaddr = kernel.function("inet_csk_addr2sockaddr")
{
}

probe inet_csk_addr2sockaddr
{
	ctracer__method_hook(0, 0x1a45bc1, $sk, 80);
}

probe inet_csk_addr2sockaddr__return = kernel.function("inet_csk_addr2sockaddr").return
{
}

probe inet_csk_addr2sockaddr__return
{
	ctracer__method_hook(1, 0x1a45bc1, $sk, 80);
}

probe inet_csk_route_req = kernel.function("inet_csk_route_req")
{
}

probe inet_csk_route_req
{
	ctracer__method_hook(0, 0x1a459dd, $sk, 80);
}

probe inet_csk_route_req__return = kernel.function("inet_csk_route_req").return
{
}

probe inet_csk_route_req__return
{
	ctracer__method_hook(1, 0x1a459dd, $sk, 80);
}

probe inet_csk_delete_keepalive_timer = kernel.function("inet_csk_delete_keepalive_timer")
{
}

probe inet_csk_delete_keepalive_timer
{
	ctracer__method_hook(0, 0x1a4593e, $sk, 80);
}

probe inet_csk_delete_keepalive_timer__return = kernel.function("inet_csk_delete_keepalive_timer").return
{
}

probe inet_csk_delete_keepalive_timer__return
{
	ctracer__method_hook(1, 0x1a4593e, $sk, 80);
}

probe inet_csk_reset_keepalive_timer = kernel.function("inet_csk_reset_keepalive_timer")
{
}

probe inet_csk_reset_keepalive_timer
{
	ctracer__method_hook(0, 0x1a458fd, $sk, 80);
}

probe inet_csk_reset_keepalive_timer__return = kernel.function("inet_csk_reset_keepalive_timer").return
{
}

probe inet_csk_reset_keepalive_timer__return
{
	ctracer__method_hook(1, 0x1a458fd, $sk, 80);
}

probe inet_csk_destroy_sock = kernel.function("inet_csk_destroy_sock")
{
}

probe inet_csk_destroy_sock
{
	ctracer__method_hook(0, 0x1a457ee, $sk, 80);
}

probe inet_csk_destroy_sock__return = kernel.function("inet_csk_destroy_sock").return
{
}

probe inet_csk_destroy_sock__return
{
	ctracer__method_hook(1, 0x1a457ee, $sk, 80);
}

probe inet_csk_compat_setsockopt = kernel.function("inet_csk_compat_setsockopt")
{
}

probe inet_csk_compat_setsockopt
{
	ctracer__method_hook(0, 0x1a456e6, $sk, 80);
}

probe inet_csk_compat_setsockopt__return = kernel.function("inet_csk_compat_setsockopt").return
{
}

probe inet_csk_compat_setsockopt__return
{
	ctracer__method_hook(1, 0x1a456e6, $sk, 80);
}

probe tcp_disconnect = kernel.function("tcp_disconnect")
{
}

probe tcp_disconnect
{
	ctracer__method_hook(0, 0x1a60523, $sk, 80);
}

probe tcp_disconnect__return = kernel.function("tcp_disconnect").return
{
}

probe tcp_disconnect__return
{
	ctracer__method_hook(1, 0x1a60523, $sk, 80);
}

probe tcp_recvmsg = kernel.function("tcp_recvmsg")
{
}

probe tcp_recvmsg
{
	ctracer__method_hook(0, 0x1a5f4b3, $sk, 80);
}

probe tcp_recvmsg__return = kernel.function("tcp_recvmsg").return
{
}

probe tcp_recvmsg__return
{
	ctracer__method_hook(1, 0x1a5f4b3, $sk, 80);
}

probe tcp_close = kernel.function("tcp_close")
{
}

probe tcp_close
{
	ctracer__method_hook(0, 0x1a5e7a1, $sk, 80);
}

probe tcp_close__return = kernel.function("tcp_close").return
{
}

probe tcp_close__return
{
	ctracer__method_hook(1, 0x1a5e7a1, $sk, 80);
}

probe tcp_read_sock = kernel.function("tcp_read_sock")
{
}

probe tcp_read_sock
{
	ctracer__method_hook(0, 0x1a5e4e1, $sk, 80);
}

probe tcp_read_sock__return = kernel.function("tcp_read_sock").return
{
}

probe tcp_read_sock__return
{
	ctracer__method_hook(1, 0x1a5e4e1, $sk, 80);
}

probe tcp_ioctl = kernel.function("tcp_ioctl")
{
}

probe tcp_ioctl
{
	ctracer__method_hook(0, 0x1a5c787, $sk, 80);
}

probe tcp_ioctl__return = kernel.function("tcp_ioctl").return
{
}

probe tcp_ioctl__return
{
	ctracer__method_hook(1, 0x1a5c787, $sk, 80);
}

probe tcp_setsockopt = kernel.function("tcp_setsockopt")
{
}

probe tcp_setsockopt
{
	ctracer__method_hook(0, 0x1a5c069, $sk, 80);
}

probe tcp_setsockopt__return = kernel.function("tcp_setsockopt").return
{
}

probe tcp_setsockopt__return
{
	ctracer__method_hook(1, 0x1a5c069, $sk, 80);
}

probe compat_tcp_setsockopt = kernel.function("compat_tcp_setsockopt")
{
}

probe compat_tcp_setsockopt
{
	ctracer__method_hook(0, 0x1a5bff4, $sk, 80);
}

probe compat_tcp_setsockopt__return = kernel.function("compat_tcp_setsockopt").return
{
}

probe compat_tcp_setsockopt__return
{
	ctracer__method_hook(1, 0x1a5bff4, $sk, 80);
}

probe do_tcp_setsockopt = kernel.function("do_tcp_setsockopt")
{
}

probe do_tcp_setsockopt
{
	ctracer__method_hook(0, 0x1a5be16, $sk, 80);
}

probe do_tcp_setsockopt__return = kernel.function("do_tcp_setsockopt").return
{
}

probe do_tcp_setsockopt__return
{
	ctracer__method_hook(1, 0x1a5be16, $sk, 80);
}

probe tcp_cleanup_rbuf = kernel.function("tcp_cleanup_rbuf")
{
}

probe tcp_cleanup_rbuf
{
	ctracer__method_hook(0, 0x1a5bccb, $sk, 80);
}

probe tcp_cleanup_rbuf__return = kernel.function("tcp_cleanup_rbuf").return
{
}

probe tcp_cleanup_rbuf__return
{
	ctracer__method_hook(1, 0x1a5bccb, $sk, 80);
}

probe tcp_prequeue_process = kernel.function("tcp_prequeue_process")
{
}

probe tcp_prequeue_process
{
	ctracer__method_hook(0, 0x1a5bc10, $sk, 80);
}

probe tcp_prequeue_process__return = kernel.function("tcp_prequeue_process").return
{
}

probe tcp_prequeue_process__return
{
	ctracer__method_hook(1, 0x1a5bc10, $sk, 80);
}

probe tcp_shutdown = kernel.function("tcp_shutdown")
{
}

probe tcp_shutdown
{
	ctracer__method_hook(0, 0x1a5bbce, $sk, 80);
}

probe tcp_shutdown__return = kernel.function("tcp_shutdown").return
{
}

probe tcp_shutdown__return
{
	ctracer__method_hook(1, 0x1a5bbce, $sk, 80);
}

probe tcp_getsockopt = kernel.function("tcp_getsockopt")
{
}

probe tcp_getsockopt
{
	ctracer__method_hook(0, 0x1a5bb4d, $sk, 80);
}

probe tcp_getsockopt__return = kernel.function("tcp_getsockopt").return
{
}

probe tcp_getsockopt__return
{
	ctracer__method_hook(1, 0x1a5bb4d, $sk, 80);
}

probe compat_tcp_getsockopt = kernel.function("compat_tcp_getsockopt")
{
}

probe compat_tcp_getsockopt
{
	ctracer__method_hook(0, 0x1a5bad8, $sk, 80);
}

probe compat_tcp_getsockopt__return = kernel.function("compat_tcp_getsockopt").return
{
}

probe compat_tcp_getsockopt__return
{
	ctracer__method_hook(1, 0x1a5bad8, $sk, 80);
}

probe do_tcp_getsockopt = kernel.function("do_tcp_getsockopt")
{
}

probe do_tcp_getsockopt
{
	ctracer__method_hook(0, 0x1a5b8ee, $sk, 80);
}

probe do_tcp_getsockopt__return = kernel.function("do_tcp_getsockopt").return
{
}

probe do_tcp_getsockopt__return
{
	ctracer__method_hook(1, 0x1a5b8ee, $sk, 80);
}

probe tcp_get_info = kernel.function("tcp_get_info")
{
}

probe tcp_get_info
{
	ctracer__method_hook(0, 0x1a5b874, $sk, 80);
}

probe tcp_get_info__return = kernel.function("tcp_get_info").return
{
}

probe tcp_get_info__return
{
	ctracer__method_hook(1, 0x1a5b874, $sk, 80);
}

probe tcp_done = kernel.function("tcp_done")
{
}

probe tcp_done
{
	ctracer__method_hook(0, 0x1a5b396, $sk, 80);
}

probe tcp_done__return = kernel.function("tcp_done").return
{
}

probe tcp_done__return
{
	ctracer__method_hook(1, 0x1a5b396, $sk, 80);
}

probe tcp_close_state = kernel.function("tcp_close_state")
{
}

probe tcp_close_state
{
	ctracer__method_hook(0, 0x1a5b199, $sk, 80);
}

probe tcp_close_state__return = kernel.function("tcp_close_state").return
{
}

probe tcp_close_state__return
{
	ctracer__method_hook(1, 0x1a5b199, $sk, 80);
}

probe tcp_rcv_established = kernel.function("tcp_rcv_established")
{
}

probe tcp_rcv_established
{
	ctracer__method_hook(0, 0x1a7a8a3, $sk, 80);
}

probe tcp_rcv_established__return = kernel.function("tcp_rcv_established").return
{
}

probe tcp_rcv_established__return
{
	ctracer__method_hook(1, 0x1a7a8a3, $sk, 80);
}

probe tcp_rcv_state_process = kernel.function("tcp_rcv_state_process")
{
}

probe tcp_rcv_state_process
{
	ctracer__method_hook(0, 0x1a79bef, $sk, 80);
}

probe tcp_rcv_state_process__return = kernel.function("tcp_rcv_state_process").return
{
}

probe tcp_rcv_state_process__return
{
	ctracer__method_hook(1, 0x1a79bef, $sk, 80);
}

probe tcp_use_frto = kernel.function("tcp_use_frto")
{
}

probe tcp_use_frto
{
	ctracer__method_hook(0, 0x1a79831, $sk, 80);
}

probe tcp_use_frto__return = kernel.function("tcp_use_frto").return
{
}

probe tcp_use_frto__return
{
	ctracer__method_hook(1, 0x1a79831, $sk, 80);
}

probe tcp_enter_frto = kernel.function("tcp_enter_frto")
{
}

probe tcp_enter_frto
{
	ctracer__method_hook(0, 0x1a79695, $sk, 80);
}

probe tcp_enter_frto__return = kernel.function("tcp_enter_frto").return
{
}

probe tcp_enter_frto__return
{
	ctracer__method_hook(1, 0x1a79695, $sk, 80);
}

probe tcp_cwnd_application_limited = kernel.function("tcp_cwnd_application_limited")
{
}

probe tcp_cwnd_application_limited
{
	ctracer__method_hook(0, 0x1a79564, $sk, 80);
}

probe tcp_cwnd_application_limited__return = kernel.function("tcp_cwnd_application_limited").return
{
}

probe tcp_cwnd_application_limited__return
{
	ctracer__method_hook(1, 0x1a79564, $sk, 80);
}

probe __tcp_checksum_complete_user = kernel.function("__tcp_checksum_complete_user")
{
}

probe __tcp_checksum_complete_user
{
	ctracer__method_hook(0, 0x1a7922f, $sk, 80);
}

probe __tcp_checksum_complete_user__return = kernel.function("__tcp_checksum_complete_user").return
{
}

probe __tcp_checksum_complete_user__return
{
	ctracer__method_hook(1, 0x1a7922f, $sk, 80);
}

probe __tcp_ack_snd_check = kernel.function("__tcp_ack_snd_check")
{
}

probe __tcp_ack_snd_check
{
	ctracer__method_hook(0, 0x1a79171, $sk, 80);
}

probe __tcp_ack_snd_check__return = kernel.function("__tcp_ack_snd_check").return
{
}

probe __tcp_ack_snd_check__return
{
	ctracer__method_hook(1, 0x1a79171, $sk, 80);
}

probe tcp_data_queue = kernel.function("tcp_data_queue")
{
}

probe tcp_data_queue
{
	ctracer__method_hook(0, 0x1a785bb, $sk, 80);
}

probe tcp_data_queue__return = kernel.function("tcp_data_queue").return
{
}

probe tcp_data_queue__return
{
	ctracer__method_hook(1, 0x1a785bb, $sk, 80);
}

probe tcp_prune_queue = kernel.function("tcp_prune_queue")
{
}

probe tcp_prune_queue
{
	ctracer__method_hook(0, 0x1a78097, $sk, 80);
}

probe tcp_prune_queue__return = kernel.function("tcp_prune_queue").return
{
}

probe tcp_prune_queue__return
{
	ctracer__method_hook(1, 0x1a78097, $sk, 80);
}

probe tcp_collapse = kernel.function("tcp_collapse")
{
}

probe tcp_collapse
{
	ctracer__method_hook(0, 0x1a77b57, $sk, 80);
}

probe tcp_collapse__return = kernel.function("tcp_collapse").return
{
}

probe tcp_collapse__return
{
	ctracer__method_hook(1, 0x1a77b57, $sk, 80);
}

probe tcp_event_data_recv = kernel.function("tcp_event_data_recv")
{
}

probe tcp_event_data_recv
{
	ctracer__method_hook(0, 0x1a77893, $sk, 80);
}

probe tcp_event_data_recv__return = kernel.function("tcp_event_data_recv").return
{
}

probe tcp_event_data_recv__return
{
	ctracer__method_hook(1, 0x1a77893, $sk, 80);
}

probe tcp_fin = kernel.function("tcp_fin")
{
}

probe tcp_fin
{
	ctracer__method_hook(0, 0x1a77409, $sk, 80);
}

probe tcp_fin__return = kernel.function("tcp_fin").return
{
}

probe tcp_fin__return
{
	ctracer__method_hook(1, 0x1a77409, $sk, 80);
}

probe tcp_urg = kernel.function("tcp_urg")
{
}

probe tcp_urg
{
	ctracer__method_hook(0, 0x1a771aa, $sk, 80);
}

probe tcp_urg__return = kernel.function("tcp_urg").return
{
}

probe tcp_urg__return
{
	ctracer__method_hook(1, 0x1a771aa, $sk, 80);
}

probe tcp_ack = kernel.function("tcp_ack")
{
}

probe tcp_ack
{
	ctracer__method_hook(0, 0x1a75877, $sk, 80);
}

probe tcp_ack__return = kernel.function("tcp_ack").return
{
}

probe tcp_ack__return
{
	ctracer__method_hook(1, 0x1a75877, $sk, 80);
}

probe tcp_sacktag_write_queue = kernel.function("tcp_sacktag_write_queue")
{
}

probe tcp_sacktag_write_queue
{
	ctracer__method_hook(0, 0x1a748a3, $sk, 80);
}

probe tcp_sacktag_write_queue__return = kernel.function("tcp_sacktag_write_queue").return
{
}

probe tcp_sacktag_write_queue__return
{
	ctracer__method_hook(1, 0x1a748a3, $sk, 80);
}

probe tcp_enter_frto_loss = kernel.function("tcp_enter_frto_loss")
{
}

probe tcp_enter_frto_loss
{
	ctracer__method_hook(0, 0x1a74789, $sk, 80);
}

probe tcp_enter_frto_loss__return = kernel.function("tcp_enter_frto_loss").return
{
}

probe tcp_enter_frto_loss__return
{
	ctracer__method_hook(1, 0x1a74789, $sk, 80);
}

probe tcp_enter_loss = kernel.function("tcp_enter_loss")
{
}

probe tcp_enter_loss
{
	ctracer__method_hook(0, 0x1a745f6, $sk, 80);
}

probe tcp_enter_loss__return = kernel.function("tcp_enter_loss").return
{
}

probe tcp_enter_loss__return
{
	ctracer__method_hook(1, 0x1a745f6, $sk, 80);
}

probe tcp_add_reno_sack = kernel.function("tcp_add_reno_sack")
{
}

probe tcp_add_reno_sack
{
	ctracer__method_hook(0, 0x1a74598, $sk, 80);
}

probe tcp_add_reno_sack__return = kernel.function("tcp_add_reno_sack").return
{
}

probe tcp_add_reno_sack__return
{
	ctracer__method_hook(1, 0x1a74598, $sk, 80);
}

probe tcp_mark_head_lost = kernel.function("tcp_mark_head_lost")
{
}

probe tcp_mark_head_lost
{
	ctracer__method_hook(0, 0x1a744c5, $sk, 80);
}

probe tcp_mark_head_lost__return = kernel.function("tcp_mark_head_lost").return
{
}

probe tcp_mark_head_lost__return
{
	ctracer__method_hook(1, 0x1a744c5, $sk, 80);
}

probe tcp_send_dupack = kernel.function("tcp_send_dupack")
{
}

probe tcp_send_dupack
{
	ctracer__method_hook(0, 0x1a7440f, $sk, 80);
}

probe tcp_send_dupack__return = kernel.function("tcp_send_dupack").return
{
}

probe tcp_send_dupack__return
{
	ctracer__method_hook(1, 0x1a7440f, $sk, 80);
}

probe tcp_reset = kernel.function("tcp_reset")
{
}

probe tcp_reset
{
	ctracer__method_hook(0, 0x1a74398, $sk, 80);
}

probe tcp_reset__return = kernel.function("tcp_reset").return
{
}

probe tcp_reset__return
{
	ctracer__method_hook(1, 0x1a74398, $sk, 80);
}

probe tcp_check_space = kernel.function("tcp_check_space")
{
}

probe tcp_check_space
{
	ctracer__method_hook(0, 0x1a74141, $sk, 80);
}

probe tcp_check_space__return = kernel.function("tcp_check_space").return
{
}

probe tcp_check_space__return
{
	ctracer__method_hook(1, 0x1a74141, $sk, 80);
}

probe tcp_ratehalving_spur_to_response = kernel.function("tcp_ratehalving_spur_to_response")
{
}

probe tcp_ratehalving_spur_to_response
{
	ctracer__method_hook(0, 0x1a73f05, $sk, 80);
}

probe tcp_ratehalving_spur_to_response__return = kernel.function("tcp_ratehalving_spur_to_response").return
{
}

probe tcp_ratehalving_spur_to_response__return
{
	ctracer__method_hook(1, 0x1a73f05, $sk, 80);
}

probe tcp_cong_avoid = kernel.function("tcp_cong_avoid")
{
}

probe tcp_cong_avoid
{
	ctracer__method_hook(0, 0x1a73e98, $sk, 80);
}

probe tcp_cong_avoid__return = kernel.function("tcp_cong_avoid").return
{
}

probe tcp_cong_avoid__return
{
	ctracer__method_hook(1, 0x1a73e98, $sk, 80);
}

probe tcp_ack_saw_tstamp = kernel.function("tcp_ack_saw_tstamp")
{
}

probe tcp_ack_saw_tstamp
{
	ctracer__method_hook(0, 0x1a73e0d, $sk, 80);
}

probe tcp_ack_saw_tstamp__return = kernel.function("tcp_ack_saw_tstamp").return
{
}

probe tcp_ack_saw_tstamp__return
{
	ctracer__method_hook(1, 0x1a73e0d, $sk, 80);
}

probe tcp_try_undo_dsack = kernel.function("tcp_try_undo_dsack")
{
}

probe tcp_try_undo_dsack
{
	ctracer__method_hook(0, 0x1a73d93, $sk, 80);
}

probe tcp_try_undo_dsack__return = kernel.function("tcp_try_undo_dsack").return
{
}

probe tcp_try_undo_dsack__return
{
	ctracer__method_hook(1, 0x1a73d93, $sk, 80);
}

probe tcp_try_undo_recovery = kernel.function("tcp_try_undo_recovery")
{
}

probe tcp_try_undo_recovery
{
	ctracer__method_hook(0, 0x1a73c37, $sk, 80);
}

probe tcp_try_undo_recovery__return = kernel.function("tcp_try_undo_recovery").return
{
}

probe tcp_try_undo_recovery__return
{
	ctracer__method_hook(1, 0x1a73c37, $sk, 80);
}

probe tcp_undo_cwr = kernel.function("tcp_undo_cwr")
{
}

probe tcp_undo_cwr
{
	ctracer__method_hook(0, 0x1a73b77, $sk, 80);
}

probe tcp_undo_cwr__return = kernel.function("tcp_undo_cwr").return
{
}

probe tcp_undo_cwr__return
{
	ctracer__method_hook(1, 0x1a73b77, $sk, 80);
}

probe tcp_cwnd_down = kernel.function("tcp_cwnd_down")
{
}

probe tcp_cwnd_down
{
	ctracer__method_hook(0, 0x1a73afe, $sk, 80);
}

probe tcp_cwnd_down__return = kernel.function("tcp_cwnd_down").return
{
}

probe tcp_cwnd_down__return
{
	ctracer__method_hook(1, 0x1a73afe, $sk, 80);
}

probe tcp_check_reno_reordering = kernel.function("tcp_check_reno_reordering")
{
}

probe tcp_check_reno_reordering
{
	ctracer__method_hook(0, 0x1a73a63, $sk, 80);
}

probe tcp_check_reno_reordering__return = kernel.function("tcp_check_reno_reordering").return
{
}

probe tcp_check_reno_reordering__return
{
	ctracer__method_hook(1, 0x1a73a63, $sk, 80);
}

probe tcp_update_reordering = kernel.function("tcp_update_reordering")
{
}

probe tcp_update_reordering
{
	ctracer__method_hook(0, 0x1a738d2, $sk, 80);
}

probe tcp_update_reordering__return = kernel.function("tcp_update_reordering").return
{
}

probe tcp_update_reordering__return
{
	ctracer__method_hook(1, 0x1a738d2, $sk, 80);
}

probe tcp_init_metrics = kernel.function("tcp_init_metrics")
{
}

probe tcp_init_metrics
{
	ctracer__method_hook(0, 0x1a7371a, $sk, 80);
}

probe tcp_init_metrics__return = kernel.function("tcp_init_metrics").return
{
}

probe tcp_init_metrics__return
{
	ctracer__method_hook(1, 0x1a7371a, $sk, 80);
}

probe tcp_enter_cwr = kernel.function("tcp_enter_cwr")
{
}

probe tcp_enter_cwr
{
	ctracer__method_hook(0, 0x1a73665, $sk, 80);
}

probe tcp_enter_cwr__return = kernel.function("tcp_enter_cwr").return
{
}

probe tcp_enter_cwr__return
{
	ctracer__method_hook(1, 0x1a73665, $sk, 80);
}

probe tcp_update_metrics = kernel.function("tcp_update_metrics")
{
}

probe tcp_update_metrics
{
	ctracer__method_hook(0, 0x1a734a9, $sk, 80);
}

probe tcp_update_metrics__return = kernel.function("tcp_update_metrics").return
{
}

probe tcp_update_metrics__return
{
	ctracer__method_hook(1, 0x1a734a9, $sk, 80);
}

probe tcp_rtt_estimator = kernel.function("tcp_rtt_estimator")
{
}

probe tcp_rtt_estimator
{
	ctracer__method_hook(0, 0x1a7341a, $sk, 80);
}

probe tcp_rtt_estimator__return = kernel.function("tcp_rtt_estimator").return
{
}

probe tcp_rtt_estimator__return
{
	ctracer__method_hook(1, 0x1a7341a, $sk, 80);
}

probe tcp_rto_min = kernel.function("tcp_rto_min")
{
}

probe tcp_rto_min
{
	ctracer__method_hook(0, 0x1a733aa, $sk, 80);
}

probe tcp_rto_min__return = kernel.function("tcp_rto_min").return
{
}

probe tcp_rto_min__return
{
	ctracer__method_hook(1, 0x1a733aa, $sk, 80);
}

probe tcp_rcv_space_adjust = kernel.function("tcp_rcv_space_adjust")
{
}

probe tcp_rcv_space_adjust
{
	ctracer__method_hook(0, 0x1a7329f, $sk, 80);
}

probe tcp_rcv_space_adjust__return = kernel.function("tcp_rcv_space_adjust").return
{
}

probe tcp_rcv_space_adjust__return
{
	ctracer__method_hook(1, 0x1a7329f, $sk, 80);
}

probe tcp_initialize_rcv_mss = kernel.function("tcp_initialize_rcv_mss")
{
}

probe tcp_initialize_rcv_mss
{
	ctracer__method_hook(0, 0x1a73181, $sk, 80);
}

probe tcp_initialize_rcv_mss__return = kernel.function("tcp_initialize_rcv_mss").return
{
}

probe tcp_initialize_rcv_mss__return
{
	ctracer__method_hook(1, 0x1a73181, $sk, 80);
}

probe tcp_init_buffer_space = kernel.function("tcp_init_buffer_space")
{
}

probe tcp_init_buffer_space
{
	ctracer__method_hook(0, 0x1a73070, $sk, 80);
}

probe tcp_init_buffer_space__return = kernel.function("tcp_init_buffer_space").return
{
}

probe tcp_init_buffer_space__return
{
	ctracer__method_hook(1, 0x1a73070, $sk, 80);
}

probe tcp_enter_quickack_mode = kernel.function("tcp_enter_quickack_mode")
{
}

probe tcp_enter_quickack_mode
{
	ctracer__method_hook(0, 0x1a72fa8, $sk, 80);
}

probe tcp_enter_quickack_mode__return = kernel.function("tcp_enter_quickack_mode").return
{
}

probe tcp_enter_quickack_mode__return
{
	ctracer__method_hook(1, 0x1a72fa8, $sk, 80);
}

probe tcp_incr_quickack = kernel.function("tcp_incr_quickack")
{
}

probe tcp_incr_quickack
{
	ctracer__method_hook(0, 0x1a72f61, $sk, 80);
}

probe tcp_incr_quickack__return = kernel.function("tcp_incr_quickack").return
{
}

probe tcp_incr_quickack__return
{
	ctracer__method_hook(1, 0x1a72f61, $sk, 80);
}

probe tcp_send_fin = kernel.function("tcp_send_fin")
{
}

probe tcp_send_fin
{
	ctracer__method_hook(0, 0x1a9187c, $sk, 80);
}

probe tcp_send_fin__return = kernel.function("tcp_send_fin").return
{
}

probe tcp_send_fin__return
{
	ctracer__method_hook(1, 0x1a9187c, $sk, 80);
}

probe tcp_send_synack = kernel.function("tcp_send_synack")
{
}

probe tcp_send_synack
{
	ctracer__method_hook(0, 0x1a91591, $sk, 80);
}

probe tcp_send_synack__return = kernel.function("tcp_send_synack").return
{
}

probe tcp_send_synack__return
{
	ctracer__method_hook(1, 0x1a91591, $sk, 80);
}

probe tcp_send_probe0 = kernel.function("tcp_send_probe0")
{
}

probe tcp_send_probe0
{
	ctracer__method_hook(0, 0x1a914a3, $sk, 80);
}

probe tcp_send_probe0__return = kernel.function("tcp_send_probe0").return
{
}

probe tcp_send_probe0__return
{
	ctracer__method_hook(1, 0x1a914a3, $sk, 80);
}

probe tcp_connect = kernel.function("tcp_connect")
{
}

probe tcp_connect
{
	ctracer__method_hook(0, 0x1a9104b, $sk, 80);
}

probe tcp_connect__return = kernel.function("tcp_connect").return
{
}

probe tcp_connect__return
{
	ctracer__method_hook(1, 0x1a9104b, $sk, 80);
}

probe tcp_simple_retransmit = kernel.function("tcp_simple_retransmit")
{
}

probe tcp_simple_retransmit
{
	ctracer__method_hook(0, 0x1a90e9d, $sk, 80);
}

probe tcp_simple_retransmit__return = kernel.function("tcp_simple_retransmit").return
{
}

probe tcp_simple_retransmit__return
{
	ctracer__method_hook(1, 0x1a90e9d, $sk, 80);
}

probe tcp_push_one = kernel.function("tcp_push_one")
{
}

probe tcp_push_one
{
	ctracer__method_hook(0, 0x1a90d9b, $sk, 80);
}

probe tcp_push_one__return = kernel.function("tcp_push_one").return
{
}

probe tcp_push_one__return
{
	ctracer__method_hook(1, 0x1a90d9b, $sk, 80);
}

probe tcp_send_delayed_ack = kernel.function("tcp_send_delayed_ack")
{
}

probe tcp_send_delayed_ack
{
	ctracer__method_hook(0, 0x1a90ce9, $sk, 80);
}

probe tcp_send_delayed_ack__return = kernel.function("tcp_send_delayed_ack").return
{
}

probe tcp_send_delayed_ack__return
{
	ctracer__method_hook(1, 0x1a90ce9, $sk, 80);
}

probe tcp_make_synack = kernel.function("tcp_make_synack")
{
}

probe tcp_make_synack
{
	ctracer__method_hook(0, 0x1a90975, $sk, 80);
}

probe tcp_make_synack__return = kernel.function("tcp_make_synack").return
{
}

probe tcp_make_synack__return
{
	ctracer__method_hook(1, 0x1a90975, $sk, 80);
}

probe tcp_send_active_reset = kernel.function("tcp_send_active_reset")
{
}

probe tcp_send_active_reset
{
	ctracer__method_hook(0, 0x1a90723, $sk, 80);
}

probe tcp_send_active_reset__return = kernel.function("tcp_send_active_reset").return
{
}

probe tcp_send_active_reset__return
{
	ctracer__method_hook(1, 0x1a90723, $sk, 80);
}

probe __tcp_push_pending_frames = kernel.function("__tcp_push_pending_frames")
{
}

probe __tcp_push_pending_frames
{
	ctracer__method_hook(0, 0x1a8fe99, $sk, 80);
}

probe __tcp_push_pending_frames__return = kernel.function("__tcp_push_pending_frames").return
{
}

probe __tcp_push_pending_frames__return
{
	ctracer__method_hook(1, 0x1a8fe99, $sk, 80);
}

probe tso_fragment = kernel.function("tso_fragment")
{
}

probe tso_fragment
{
	ctracer__method_hook(0, 0x1a8f948, $sk, 80);
}

probe tso_fragment__return = kernel.function("tso_fragment").return
{
}

probe tso_fragment__return
{
	ctracer__method_hook(1, 0x1a8f948, $sk, 80);
}

probe tcp_xmit_retransmit_queue = kernel.function("tcp_xmit_retransmit_queue")
{
}

probe tcp_xmit_retransmit_queue
{
	ctracer__method_hook(0, 0x1a8f673, $sk, 80);
}

probe tcp_xmit_retransmit_queue__return = kernel.function("tcp_xmit_retransmit_queue").return
{
}

probe tcp_xmit_retransmit_queue__return
{
	ctracer__method_hook(1, 0x1a8f673, $sk, 80);
}

probe tcp_retransmit_skb = kernel.function("tcp_retransmit_skb")
{
}

probe tcp_retransmit_skb
{
	ctracer__method_hook(0, 0x1a8efd5, $sk, 80);
}

probe tcp_retransmit_skb__return = kernel.function("tcp_retransmit_skb").return
{
}

probe tcp_retransmit_skb__return
{
	ctracer__method_hook(1, 0x1a8efd5, $sk, 80);
}

probe tcp_write_wakeup = kernel.function("tcp_write_wakeup")
{
}

probe tcp_write_wakeup
{
	ctracer__method_hook(0, 0x1a8edf1, $sk, 80);
}

probe tcp_write_wakeup__return = kernel.function("tcp_write_wakeup").return
{
}

probe tcp_write_wakeup__return
{
	ctracer__method_hook(1, 0x1a8edf1, $sk, 80);
}

probe tcp_fragment = kernel.function("tcp_fragment")
{
}

probe tcp_fragment
{
	ctracer__method_hook(0, 0x1a8e924, $sk, 80);
}

probe tcp_fragment__return = kernel.function("tcp_fragment").return
{
}

probe tcp_fragment__return
{
	ctracer__method_hook(1, 0x1a8e924, $sk, 80);
}

probe tcp_trim_head = kernel.function("tcp_trim_head")
{
}

probe tcp_trim_head
{
	ctracer__method_hook(0, 0x1a8e813, $sk, 80);
}

probe tcp_trim_head__return = kernel.function("tcp_trim_head").return
{
}

probe tcp_trim_head__return
{
	ctracer__method_hook(1, 0x1a8e813, $sk, 80);
}

probe tcp_cwnd_validate = kernel.function("tcp_cwnd_validate")
{
}

probe tcp_cwnd_validate
{
	ctracer__method_hook(0, 0x1a8e73c, $sk, 80);
}

probe tcp_cwnd_validate__return = kernel.function("tcp_cwnd_validate").return
{
}

probe tcp_cwnd_validate__return
{
	ctracer__method_hook(1, 0x1a8e73c, $sk, 80);
}

probe tcp_send_ack = kernel.function("tcp_send_ack")
{
}

probe tcp_send_ack
{
	ctracer__method_hook(0, 0x1a8e635, $sk, 80);
}

probe tcp_send_ack__return = kernel.function("tcp_send_ack").return
{
}

probe tcp_send_ack__return
{
	ctracer__method_hook(1, 0x1a8e635, $sk, 80);
}

probe tcp_xmit_probe_skb = kernel.function("tcp_xmit_probe_skb")
{
}

probe tcp_xmit_probe_skb
{
	ctracer__method_hook(0, 0x1a8e597, $sk, 80);
}

probe tcp_xmit_probe_skb__return = kernel.function("tcp_xmit_probe_skb").return
{
}

probe tcp_xmit_probe_skb__return
{
	ctracer__method_hook(1, 0x1a8e597, $sk, 80);
}

probe tcp_transmit_skb = kernel.function("tcp_transmit_skb")
{
}

probe tcp_transmit_skb
{
	ctracer__method_hook(0, 0x1a8ddb4, $sk, 80);
}

probe tcp_transmit_skb__return = kernel.function("tcp_transmit_skb").return
{
}

probe tcp_transmit_skb__return
{
	ctracer__method_hook(1, 0x1a8ddb4, $sk, 80);
}

probe update_send_head = kernel.function("update_send_head")
{
}

probe update_send_head
{
	ctracer__method_hook(0, 0x1a8d8e5, $sk, 80);
}

probe update_send_head__return = kernel.function("update_send_head").return
{
}

probe update_send_head__return
{
	ctracer__method_hook(1, 0x1a8d8e5, $sk, 80);
}

probe __tcp_select_window = kernel.function("__tcp_select_window")
{
}

probe __tcp_select_window
{
	ctracer__method_hook(0, 0x1a8d7e7, $sk, 80);
}

probe __tcp_select_window__return = kernel.function("__tcp_select_window").return
{
}

probe __tcp_select_window__return
{
	ctracer__method_hook(1, 0x1a8d7e7, $sk, 80);
}

probe tcp_may_send_now = kernel.function("tcp_may_send_now")
{
}

probe tcp_may_send_now
{
	ctracer__method_hook(0, 0x1a8d778, $sk, 80);
}

probe tcp_may_send_now__return = kernel.function("tcp_may_send_now").return
{
}

probe tcp_may_send_now__return
{
	ctracer__method_hook(1, 0x1a8d778, $sk, 80);
}

probe tcp_snd_test = kernel.function("tcp_snd_test")
{
}

probe tcp_snd_test
{
	ctracer__method_hook(0, 0x1a8d5ec, $sk, 80);
}

probe tcp_snd_test__return = kernel.function("tcp_snd_test").return
{
}

probe tcp_snd_test__return
{
	ctracer__method_hook(1, 0x1a8d5ec, $sk, 80);
}

probe tcp_init_tso_segs = kernel.function("tcp_init_tso_segs")
{
}

probe tcp_init_tso_segs
{
	ctracer__method_hook(0, 0x1a8d553, $sk, 80);
}

probe tcp_init_tso_segs__return = kernel.function("tcp_init_tso_segs").return
{
}

probe tcp_init_tso_segs__return
{
	ctracer__method_hook(1, 0x1a8d553, $sk, 80);
}

probe tcp_current_mss = kernel.function("tcp_current_mss")
{
}

probe tcp_current_mss
{
	ctracer__method_hook(0, 0x1a8d351, $sk, 80);
}

probe tcp_current_mss__return = kernel.function("tcp_current_mss").return
{
}

probe tcp_current_mss__return
{
	ctracer__method_hook(1, 0x1a8d351, $sk, 80);
}

probe tcp_sync_mss = kernel.function("tcp_sync_mss")
{
}

probe tcp_sync_mss
{
	ctracer__method_hook(0, 0x1a8d2b8, $sk, 80);
}

probe tcp_sync_mss__return = kernel.function("tcp_sync_mss").return
{
}

probe tcp_sync_mss__return
{
	ctracer__method_hook(1, 0x1a8d2b8, $sk, 80);
}

probe tcp_mtup_init = kernel.function("tcp_mtup_init")
{
}

probe tcp_mtup_init
{
	ctracer__method_hook(0, 0x1a8d272, $sk, 80);
}

probe tcp_mtup_init__return = kernel.function("tcp_mtup_init").return
{
}

probe tcp_mtup_init__return
{
	ctracer__method_hook(1, 0x1a8d272, $sk, 80);
}

probe tcp_mtu_to_mss = kernel.function("tcp_mtu_to_mss")
{
}

probe tcp_mtu_to_mss
{
	ctracer__method_hook(0, 0x1a8d1b0, $sk, 80);
}

probe tcp_mtu_to_mss__return = kernel.function("tcp_mtu_to_mss").return
{
}

probe tcp_mtu_to_mss__return
{
	ctracer__method_hook(1, 0x1a8d1b0, $sk, 80);
}

probe tcp_set_skb_tso_segs = kernel.function("tcp_set_skb_tso_segs")
{
}

probe tcp_set_skb_tso_segs
{
	ctracer__method_hook(0, 0x1a8d0e1, $sk, 80);
}

probe tcp_set_skb_tso_segs__return = kernel.function("tcp_set_skb_tso_segs").return
{
}

probe tcp_set_skb_tso_segs__return
{
	ctracer__method_hook(1, 0x1a8d0e1, $sk, 80);
}

probe tcp_set_keepalive = kernel.function("tcp_set_keepalive")
{
}

probe tcp_set_keepalive
{
	ctracer__method_hook(0, 0x1aa23cf, $sk, 80);
}

probe tcp_set_keepalive__return = kernel.function("tcp_set_keepalive").return
{
}

probe tcp_set_keepalive__return
{
	ctracer__method_hook(1, 0x1aa23cf, $sk, 80);
}

probe tcp_out_of_resources = kernel.function("tcp_out_of_resources")
{
}

probe tcp_out_of_resources
{
	ctracer__method_hook(0, 0x1aa22e7, $sk, 80);
}

probe tcp_out_of_resources__return = kernel.function("tcp_out_of_resources").return
{
}

probe tcp_out_of_resources__return
{
	ctracer__method_hook(1, 0x1aa22e7, $sk, 80);
}

probe tcp_write_err = kernel.function("tcp_write_err")
{
}

probe tcp_write_err
{
	ctracer__method_hook(0, 0x1aa2276, $sk, 80);
}

probe tcp_write_err__return = kernel.function("tcp_write_err").return
{
}

probe tcp_write_err__return
{
	ctracer__method_hook(1, 0x1aa2276, $sk, 80);
}

probe tcp_init_xmit_timers = kernel.function("tcp_init_xmit_timers")
{
}

probe tcp_init_xmit_timers
{
	ctracer__method_hook(0, 0x1aa2247, $sk, 80);
}

probe tcp_init_xmit_timers__return = kernel.function("tcp_init_xmit_timers").return
{
}

probe tcp_init_xmit_timers__return
{
	ctracer__method_hook(1, 0x1aa2247, $sk, 80);
}

probe tcp_orphan_retries = kernel.function("tcp_orphan_retries")
{
}

probe tcp_orphan_retries
{
	ctracer__method_hook(0, 0x1aa21fd, $sk, 80);
}

probe tcp_orphan_retries__return = kernel.function("tcp_orphan_retries").return
{
}

probe tcp_orphan_retries__return
{
	ctracer__method_hook(1, 0x1aa21fd, $sk, 80);
}

probe tcp_v4_conn_request = kernel.function("tcp_v4_conn_request")
{
}

probe tcp_v4_conn_request
{
	ctracer__method_hook(0, 0x1abc061, $sk, 80);
}

probe tcp_v4_conn_request__return = kernel.function("tcp_v4_conn_request").return
{
}

probe tcp_v4_conn_request__return
{
	ctracer__method_hook(1, 0x1abc061, $sk, 80);
}

probe tcp_v4_connect = kernel.function("tcp_v4_connect")
{
}

probe tcp_v4_connect
{
	ctracer__method_hook(0, 0x1abb65e, $sk, 80);
}

probe tcp_v4_connect__return = kernel.function("tcp_v4_connect").return
{
}

probe tcp_v4_connect__return
{
	ctracer__method_hook(1, 0x1abb65e, $sk, 80);
}

probe tcp_v4_destroy_sock = kernel.function("tcp_v4_destroy_sock")
{
}

probe tcp_v4_destroy_sock
{
	ctracer__method_hook(0, 0x1abb15f, $sk, 80);
}

probe tcp_v4_destroy_sock__return = kernel.function("tcp_v4_destroy_sock").return
{
}

probe tcp_v4_destroy_sock__return
{
	ctracer__method_hook(1, 0x1abb15f, $sk, 80);
}

probe tcp_v4_parse_md5_keys = kernel.function("tcp_v4_parse_md5_keys")
{
}

probe tcp_v4_parse_md5_keys
{
	ctracer__method_hook(0, 0x1abaf9d, $sk, 80);
}

probe tcp_v4_parse_md5_keys__return = kernel.function("tcp_v4_parse_md5_keys").return
{
}

probe tcp_v4_parse_md5_keys__return
{
	ctracer__method_hook(1, 0x1abaf9d, $sk, 80);
}

probe tcp_v4_send_check = kernel.function("tcp_v4_send_check")
{
}

probe tcp_v4_send_check
{
	ctracer__method_hook(0, 0x1abacca, $sk, 80);
}

probe tcp_v4_send_check__return = kernel.function("tcp_v4_send_check").return
{
}

probe tcp_v4_send_check__return
{
	ctracer__method_hook(1, 0x1abacca, $sk, 80);
}

probe tcp_v4_syn_recv_sock = kernel.function("tcp_v4_syn_recv_sock")
{
}

probe tcp_v4_syn_recv_sock
{
	ctracer__method_hook(0, 0x1aba813, $sk, 80);
}

probe tcp_v4_syn_recv_sock__return = kernel.function("tcp_v4_syn_recv_sock").return
{
}

probe tcp_v4_syn_recv_sock__return
{
	ctracer__method_hook(1, 0x1aba813, $sk, 80);
}

probe tcp_twsk_unique = kernel.function("tcp_twsk_unique")
{
}

probe tcp_twsk_unique
{
	ctracer__method_hook(0, 0x1aba6f1, $sk, 80);
}

probe tcp_twsk_unique__return = kernel.function("tcp_twsk_unique").return
{
}

probe tcp_twsk_unique__return
{
	ctracer__method_hook(1, 0x1aba6f1, $sk, 80);
}

probe tcp_v4_init_sock = kernel.function("tcp_v4_init_sock")
{
}

probe tcp_v4_init_sock
{
	ctracer__method_hook(0, 0x1aba5d5, $sk, 80);
}

probe tcp_v4_init_sock__return = kernel.function("tcp_v4_init_sock").return
{
}

probe tcp_v4_init_sock__return
{
	ctracer__method_hook(1, 0x1aba5d5, $sk, 80);
}

probe tcp_v4_remember_stamp = kernel.function("tcp_v4_remember_stamp")
{
}

probe tcp_v4_remember_stamp
{
	ctracer__method_hook(0, 0x1aba520, $sk, 80);
}

probe tcp_v4_remember_stamp__return = kernel.function("tcp_v4_remember_stamp").return
{
}

probe tcp_v4_remember_stamp__return
{
	ctracer__method_hook(1, 0x1aba520, $sk, 80);
}

probe tcp_v4_calc_md5_hash = kernel.function("tcp_v4_calc_md5_hash")
{
}

probe tcp_v4_calc_md5_hash
{
	ctracer__method_hook(0, 0x1aba3e0, $sk, 80);
}

probe tcp_v4_calc_md5_hash__return = kernel.function("tcp_v4_calc_md5_hash").return
{
}

probe tcp_v4_calc_md5_hash__return
{
	ctracer__method_hook(1, 0x1aba3e0, $sk, 80);
}

probe tcp_v4_md5_add_func = kernel.function("tcp_v4_md5_add_func")
{
}

probe tcp_v4_md5_add_func
{
	ctracer__method_hook(0, 0x1aba37c, $sk, 80);
}

probe tcp_v4_md5_add_func__return = kernel.function("tcp_v4_md5_add_func").return
{
}

probe tcp_v4_md5_add_func__return
{
	ctracer__method_hook(1, 0x1aba37c, $sk, 80);
}

probe tcp_v4_md5_lookup = kernel.function("tcp_v4_md5_lookup")
{
}

probe tcp_v4_md5_lookup
{
	ctracer__method_hook(0, 0x1aba337, $sk, 80);
}

probe tcp_v4_md5_lookup__return = kernel.function("tcp_v4_md5_lookup").return
{
}

probe tcp_v4_md5_lookup__return
{
	ctracer__method_hook(1, 0x1aba337, $sk, 80);
}

probe tcp_v4_reqsk_md5_lookup = kernel.function("tcp_v4_reqsk_md5_lookup")
{
}

probe tcp_v4_reqsk_md5_lookup
{
	ctracer__method_hook(0, 0x1aba2f3, $sk, 80);
}

probe tcp_v4_reqsk_md5_lookup__return = kernel.function("tcp_v4_reqsk_md5_lookup").return
{
}

probe tcp_v4_reqsk_md5_lookup__return
{
	ctracer__method_hook(1, 0x1aba2f3, $sk, 80);
}

probe tcp_unhash = kernel.function("tcp_unhash")
{
}

probe tcp_unhash
{
	ctracer__method_hook(0, 0x1aba183, $sk, 80);
}

probe tcp_unhash__return = kernel.function("tcp_unhash").return
{
}

probe tcp_unhash__return
{
	ctracer__method_hook(1, 0x1aba183, $sk, 80);
}

probe tcp_v4_md5_do_add = kernel.function("tcp_v4_md5_do_add")
{
}

probe tcp_v4_md5_do_add
{
	ctracer__method_hook(0, 0x1ab9fda, $sk, 80);
}

probe tcp_v4_md5_do_add__return = kernel.function("tcp_v4_md5_do_add").return
{
}

probe tcp_v4_md5_do_add__return
{
	ctracer__method_hook(1, 0x1ab9fda, $sk, 80);
}

probe tcp_v4_md5_do_del = kernel.function("tcp_v4_md5_do_del")
{
}

probe tcp_v4_md5_do_del
{
	ctracer__method_hook(0, 0x1ab9f51, $sk, 80);
}

probe tcp_v4_md5_do_del__return = kernel.function("tcp_v4_md5_do_del").return
{
}

probe tcp_v4_md5_do_del__return
{
	ctracer__method_hook(1, 0x1ab9f51, $sk, 80);
}

probe tcp_v4_do_rcv = kernel.function("tcp_v4_do_rcv")
{
}

probe tcp_v4_do_rcv
{
	ctracer__method_hook(0, 0x1ab99f2, $sk, 80);
}

probe tcp_v4_do_rcv__return = kernel.function("tcp_v4_do_rcv").return
{
}

probe tcp_v4_do_rcv__return
{
	ctracer__method_hook(1, 0x1ab99f2, $sk, 80);
}

probe tcp_v4_send_synack = kernel.function("tcp_v4_send_synack")
{
}

probe tcp_v4_send_synack
{
	ctracer__method_hook(0, 0x1ab87ce, $sk, 80);
}

probe tcp_v4_send_synack__return = kernel.function("tcp_v4_send_synack").return
{
}

probe tcp_v4_send_synack__return
{
	ctracer__method_hook(1, 0x1ab87ce, $sk, 80);
}

probe tcp_v4_send_reset = kernel.function("tcp_v4_send_reset")
{
}

probe tcp_v4_send_reset
{
	ctracer__method_hook(0, 0x1ab85a0, $sk, 80);
}

probe tcp_v4_send_reset__return = kernel.function("tcp_v4_send_reset").return
{
}

probe tcp_v4_send_reset__return
{
	ctracer__method_hook(1, 0x1ab85a0, $sk, 80);
}

probe tcp_v4_hash = kernel.function("tcp_v4_hash")
{
}

probe tcp_v4_hash
{
	ctracer__method_hook(0, 0x1ab7c9f, $sk, 80);
}

probe tcp_v4_hash__return = kernel.function("tcp_v4_hash").return
{
}

probe tcp_v4_hash__return
{
	ctracer__method_hook(1, 0x1ab7c9f, $sk, 80);
}

probe tcp_v4_get_port = kernel.function("tcp_v4_get_port")
{
}

probe tcp_v4_get_port
{
	ctracer__method_hook(0, 0x1ab7bce, $sk, 80);
}

probe tcp_v4_get_port__return = kernel.function("tcp_v4_get_port").return
{
}

probe tcp_v4_get_port__return
{
	ctracer__method_hook(1, 0x1ab7bce, $sk, 80);
}

probe tcp_v4_md5_do_lookup = kernel.function("tcp_v4_md5_do_lookup")
{
}

probe tcp_v4_md5_do_lookup
{
	ctracer__method_hook(0, 0x1ab7b75, $sk, 80);
}

probe tcp_v4_md5_do_lookup__return = kernel.function("tcp_v4_md5_do_lookup").return
{
}

probe tcp_v4_md5_do_lookup__return
{
	ctracer__method_hook(1, 0x1ab7b75, $sk, 80);
}

probe tcp_time_wait = kernel.function("tcp_time_wait")
{
}

probe tcp_time_wait
{
	ctracer__method_hook(0, 0x1ad1431, $sk, 80);
}

probe tcp_time_wait__return = kernel.function("tcp_time_wait").return
{
}

probe tcp_time_wait__return
{
	ctracer__method_hook(1, 0x1ad1431, $sk, 80);
}

probe tcp_create_openreq_child = kernel.function("tcp_create_openreq_child")
{
}

probe tcp_create_openreq_child
{
	ctracer__method_hook(0, 0x1ad109b, $sk, 80);
}

probe tcp_create_openreq_child__return = kernel.function("tcp_create_openreq_child").return
{
}

probe tcp_create_openreq_child__return
{
	ctracer__method_hook(1, 0x1ad109b, $sk, 80);
}

probe tcp_check_req = kernel.function("tcp_check_req")
{
}

probe tcp_check_req
{
	ctracer__method_hook(0, 0x1ad0af2, $sk, 80);
}

probe tcp_check_req__return = kernel.function("tcp_check_req").return
{
}

probe tcp_check_req__return
{
	ctracer__method_hook(1, 0x1ad0af2, $sk, 80);
}

probe tcp_twsk_destructor = kernel.function("tcp_twsk_destructor")
{
}

probe tcp_twsk_destructor
{
	ctracer__method_hook(0, 0x1ad095c, $sk, 80);
}

probe tcp_twsk_destructor__return = kernel.function("tcp_twsk_destructor").return
{
}

probe tcp_twsk_destructor__return
{
	ctracer__method_hook(1, 0x1ad095c, $sk, 80);
}

probe tcp_child_process = kernel.function("tcp_child_process")
{
}

probe tcp_child_process
{
	ctracer__method_hook(0, 0x1ad081b, $parent, 80);
}

probe tcp_child_process__return = kernel.function("tcp_child_process").return
{
}

probe tcp_child_process__return
{
	ctracer__method_hook(1, 0x1ad081b, $parent, 80);
}

probe tcp_init_congestion_control = kernel.function("tcp_init_congestion_control")
{
}

probe tcp_init_congestion_control
{
	ctracer__method_hook(0, 0x1ae2994, $sk, 80);
}

probe tcp_init_congestion_control__return = kernel.function("tcp_init_congestion_control").return
{
}

probe tcp_init_congestion_control__return
{
	ctracer__method_hook(1, 0x1ae2994, $sk, 80);
}

probe tcp_reno_ssthresh = kernel.function("tcp_reno_ssthresh")
{
}

probe tcp_reno_ssthresh
{
	ctracer__method_hook(0, 0x1ae2956, $sk, 80);
}

probe tcp_reno_ssthresh__return = kernel.function("tcp_reno_ssthresh").return
{
}

probe tcp_reno_ssthresh__return
{
	ctracer__method_hook(1, 0x1ae2956, $sk, 80);
}

probe tcp_reno_cong_avoid = kernel.function("tcp_reno_cong_avoid")
{
}

probe tcp_reno_cong_avoid
{
	ctracer__method_hook(0, 0x1ae285f, $sk, 80);
}

probe tcp_reno_cong_avoid__return = kernel.function("tcp_reno_cong_avoid").return
{
}

probe tcp_reno_cong_avoid__return
{
	ctracer__method_hook(1, 0x1ae285f, $sk, 80);
}

probe tcp_set_congestion_control = kernel.function("tcp_set_congestion_control")
{
}

probe tcp_set_congestion_control
{
	ctracer__method_hook(0, 0x1ae2439, $sk, 80);
}

probe tcp_set_congestion_control__return = kernel.function("tcp_set_congestion_control").return
{
}

probe tcp_set_congestion_control__return
{
	ctracer__method_hook(1, 0x1ae2439, $sk, 80);
}

probe tcp_cleanup_congestion_control = kernel.function("tcp_cleanup_congestion_control")
{
}

probe tcp_cleanup_congestion_control
{
	ctracer__method_hook(0, 0x1ae23ad, $sk, 80);
}

probe tcp_cleanup_congestion_control__return = kernel.function("tcp_cleanup_congestion_control").return
{
}

probe tcp_cleanup_congestion_control__return
{
	ctracer__method_hook(1, 0x1ae23ad, $sk, 80);
}

probe ip4_datagram_connect = kernel.function("ip4_datagram_connect")
{
}

probe ip4_datagram_connect
{
	ctracer__method_hook(0, 0x1af1fc2, $sk, 80);
}

probe ip4_datagram_connect__return = kernel.function("ip4_datagram_connect").return
{
}

probe ip4_datagram_connect__return
{
	ctracer__method_hook(1, 0x1af1fc2, $sk, 80);
}

probe raw_sendmsg = kernel.function("raw_sendmsg")
{
}

probe raw_sendmsg
{
	ctracer__method_hook(0, 0x1b05541, $sk, 80);
}

probe raw_sendmsg__return = kernel.function("raw_sendmsg").return
{
}

probe raw_sendmsg__return
{
	ctracer__method_hook(1, 0x1b05541, $sk, 80);
}

probe raw_err = kernel.function("raw_err")
{
}

probe raw_err
{
	ctracer__method_hook(0, 0x1b051ec, $sk, 80);
}

probe raw_err__return = kernel.function("raw_err").return
{
}

probe raw_err__return
{
	ctracer__method_hook(1, 0x1b051ec, $sk, 80);
}

probe raw_recvmsg = kernel.function("raw_recvmsg")
{
}

probe raw_recvmsg
{
	ctracer__method_hook(0, 0x1b05045, $sk, 80);
}

probe raw_recvmsg__return = kernel.function("raw_recvmsg").return
{
}

probe raw_recvmsg__return
{
	ctracer__method_hook(1, 0x1b05045, $sk, 80);
}

probe raw_bind = kernel.function("raw_bind")
{
}

probe raw_bind
{
	ctracer__method_hook(0, 0x1b04e96, $sk, 80);
}

probe raw_bind__return = kernel.function("raw_bind").return
{
}

probe raw_bind__return
{
	ctracer__method_hook(1, 0x1b04e96, $sk, 80);
}

probe raw_v4_hash = kernel.function("raw_v4_hash")
{
}

probe raw_v4_hash
{
	ctracer__method_hook(0, 0x1b04d5b, $sk, 80);
}

probe raw_v4_hash__return = kernel.function("raw_v4_hash").return
{
}

probe raw_v4_hash__return
{
	ctracer__method_hook(1, 0x1b04d5b, $sk, 80);
}

probe raw_rcv = kernel.function("raw_rcv")
{
}

probe raw_rcv
{
	ctracer__method_hook(0, 0x1b0494c, $sk, 80);
}

probe raw_rcv__return = kernel.function("raw_rcv").return
{
}

probe raw_rcv__return
{
	ctracer__method_hook(1, 0x1b0494c, $sk, 80);
}

probe raw_close = kernel.function("raw_close")
{
}

probe raw_close
{
	ctracer__method_hook(0, 0x1b0450f, $sk, 80);
}

probe raw_close__return = kernel.function("raw_close").return
{
}

probe raw_close__return
{
	ctracer__method_hook(1, 0x1b0450f, $sk, 80);
}

probe raw_setsockopt = kernel.function("raw_setsockopt")
{
}

probe raw_setsockopt
{
	ctracer__method_hook(0, 0x1b04330, $sk, 80);
}

probe raw_setsockopt__return = kernel.function("raw_setsockopt").return
{
}

probe raw_setsockopt__return
{
	ctracer__method_hook(1, 0x1b04330, $sk, 80);
}

probe raw_getsockopt = kernel.function("raw_getsockopt")
{
}

probe raw_getsockopt
{
	ctracer__method_hook(0, 0x1b042bc, $sk, 80);
}

probe raw_getsockopt__return = kernel.function("raw_getsockopt").return
{
}

probe raw_getsockopt__return
{
	ctracer__method_hook(1, 0x1b042bc, $sk, 80);
}

probe compat_raw_setsockopt = kernel.function("compat_raw_setsockopt")
{
}

probe compat_raw_setsockopt
{
	ctracer__method_hook(0, 0x1b04248, $sk, 80);
}

probe compat_raw_setsockopt__return = kernel.function("compat_raw_setsockopt").return
{
}

probe compat_raw_setsockopt__return
{
	ctracer__method_hook(1, 0x1b04248, $sk, 80);
}

probe do_raw_setsockopt = kernel.function("do_raw_setsockopt")
{
}

probe do_raw_setsockopt
{
	ctracer__method_hook(0, 0x1b041ab, $sk, 80);
}

probe do_raw_setsockopt__return = kernel.function("do_raw_setsockopt").return
{
}

probe do_raw_setsockopt__return
{
	ctracer__method_hook(1, 0x1b041ab, $sk, 80);
}

probe compat_raw_getsockopt = kernel.function("compat_raw_getsockopt")
{
}

probe compat_raw_getsockopt
{
	ctracer__method_hook(0, 0x1b04100, $sk, 80);
}

probe compat_raw_getsockopt__return = kernel.function("compat_raw_getsockopt").return
{
}

probe compat_raw_getsockopt__return
{
	ctracer__method_hook(1, 0x1b04100, $sk, 80);
}

probe do_raw_getsockopt = kernel.function("do_raw_getsockopt")
{
}

probe do_raw_getsockopt
{
	ctracer__method_hook(0, 0x1b03ffe, $sk, 80);
}

probe do_raw_getsockopt__return = kernel.function("do_raw_getsockopt").return
{
}

probe do_raw_getsockopt__return
{
	ctracer__method_hook(1, 0x1b03ffe, $sk, 80);
}

probe raw_init = kernel.function("raw_init")
{
}

probe raw_init
{
	ctracer__method_hook(0, 0x1b03f2e, $sk, 80);
}

probe raw_init__return = kernel.function("raw_init").return
{
}

probe raw_init__return
{
	ctracer__method_hook(1, 0x1b03f2e, $sk, 80);
}

probe raw_rcv_skb = kernel.function("raw_rcv_skb")
{
}

probe raw_rcv_skb
{
	ctracer__method_hook(0, 0x1b03eec, $sk, 80);
}

probe raw_rcv_skb__return = kernel.function("raw_rcv_skb").return
{
}

probe raw_rcv_skb__return
{
	ctracer__method_hook(1, 0x1b03eec, $sk, 80);
}

probe raw_v4_unhash = kernel.function("raw_v4_unhash")
{
}

probe raw_v4_unhash
{
	ctracer__method_hook(0, 0x1b03d76, $sk, 80);
}

probe raw_v4_unhash__return = kernel.function("raw_v4_unhash").return
{
}

probe raw_v4_unhash__return
{
	ctracer__method_hook(1, 0x1b03d76, $sk, 80);
}

probe raw_get_next = kernel.function("raw_get_next")
{
}

probe raw_get_next
{
	ctracer__method_hook(0, 0x1b03b4d, $sk, 80);
}

probe raw_get_next__return = kernel.function("raw_get_next").return
{
}

probe raw_get_next__return
{
	ctracer__method_hook(1, 0x1b03b4d, $sk, 80);
}

probe __raw_v4_lookup = kernel.function("__raw_v4_lookup")
{
}

probe __raw_v4_lookup
{
	ctracer__method_hook(0, 0x1b039ad, $sk, 80);
}

probe __raw_v4_lookup__return = kernel.function("__raw_v4_lookup").return
{
}

probe __raw_v4_lookup__return
{
	ctracer__method_hook(1, 0x1b039ad, $sk, 80);
}

probe udp_sendpage = kernel.function("udp_sendpage")
{
}

probe udp_sendpage
{
	ctracer__method_hook(0, 0x1b1aed5, $sk, 80);
}

probe udp_sendpage__return = kernel.function("udp_sendpage").return
{
}

probe udp_sendpage__return
{
	ctracer__method_hook(1, 0x1b1aed5, $sk, 80);
}

probe udp_recvmsg = kernel.function("udp_recvmsg")
{
}

probe udp_recvmsg
{
	ctracer__method_hook(0, 0x1b1ac3e, $sk, 80);
}

probe udp_recvmsg__return = kernel.function("udp_recvmsg").return
{
}

probe udp_recvmsg__return
{
	ctracer__method_hook(1, 0x1b1ac3e, $sk, 80);
}

probe udp_lib_unhash = kernel.function("udp_lib_unhash")
{
}

probe udp_lib_unhash
{
	ctracer__method_hook(0, 0x1b1aa28, $sk, 80);
}

probe udp_lib_unhash__return = kernel.function("udp_lib_unhash").return
{
}

probe udp_lib_unhash__return
{
	ctracer__method_hook(1, 0x1b1aa28, $sk, 80);
}

probe udp_ioctl = kernel.function("udp_ioctl")
{
}

probe udp_ioctl
{
	ctracer__method_hook(0, 0x1b1a84a, $sk, 80);
}

probe udp_ioctl__return = kernel.function("udp_ioctl").return
{
}

probe udp_ioctl__return
{
	ctracer__method_hook(1, 0x1b1a84a, $sk, 80);
}

probe udp_sendmsg = kernel.function("udp_sendmsg")
{
}

probe udp_sendmsg
{
	ctracer__method_hook(0, 0x1b1a083, $sk, 80);
}

probe udp_sendmsg__return = kernel.function("udp_sendmsg").return
{
}

probe udp_sendmsg__return
{
	ctracer__method_hook(1, 0x1b1a083, $sk, 80);
}

probe udp_disconnect = kernel.function("udp_disconnect")
{
}

probe udp_disconnect
{
	ctracer__method_hook(0, 0x1b19f13, $sk, 80);
}

probe udp_disconnect__return = kernel.function("udp_disconnect").return
{
}

probe udp_disconnect__return
{
	ctracer__method_hook(1, 0x1b19f13, $sk, 80);
}

probe udp_queue_rcv_skb = kernel.function("udp_queue_rcv_skb")
{
}

probe udp_queue_rcv_skb
{
	ctracer__method_hook(0, 0x1b1904f, $sk, 80);
}

probe udp_queue_rcv_skb__return = kernel.function("udp_queue_rcv_skb").return
{
}

probe udp_queue_rcv_skb__return
{
	ctracer__method_hook(1, 0x1b1904f, $sk, 80);
}

probe udp_destroy_sock = kernel.function("udp_destroy_sock")
{
}

probe udp_destroy_sock
{
	ctracer__method_hook(0, 0x1b19007, $sk, 80);
}

probe udp_destroy_sock__return = kernel.function("udp_destroy_sock").return
{
}

probe udp_destroy_sock__return
{
	ctracer__method_hook(1, 0x1b19007, $sk, 80);
}

probe udp_flush_pending_frames = kernel.function("udp_flush_pending_frames")
{
}

probe udp_flush_pending_frames
{
	ctracer__method_hook(0, 0x1b18fcc, $sk, 80);
}

probe udp_flush_pending_frames__return = kernel.function("udp_flush_pending_frames").return
{
}

probe udp_flush_pending_frames__return
{
	ctracer__method_hook(1, 0x1b18fcc, $sk, 80);
}

probe udp_setsockopt = kernel.function("udp_setsockopt")
{
}

probe udp_setsockopt
{
	ctracer__method_hook(0, 0x1b18f57, $sk, 80);
}

probe udp_setsockopt__return = kernel.function("udp_setsockopt").return
{
}

probe udp_setsockopt__return
{
	ctracer__method_hook(1, 0x1b18f57, $sk, 80);
}

probe compat_udp_setsockopt = kernel.function("compat_udp_setsockopt")
{
}

probe compat_udp_setsockopt
{
	ctracer__method_hook(0, 0x1b18ee2, $sk, 80);
}

probe compat_udp_setsockopt__return = kernel.function("compat_udp_setsockopt").return
{
}

probe compat_udp_setsockopt__return
{
	ctracer__method_hook(1, 0x1b18ee2, $sk, 80);
}

probe udp_lib_setsockopt = kernel.function("udp_lib_setsockopt")
{
}

probe udp_lib_setsockopt
{
	ctracer__method_hook(0, 0x1b18df5, $sk, 80);
}

probe udp_lib_setsockopt__return = kernel.function("udp_lib_setsockopt").return
{
}

probe udp_lib_setsockopt__return
{
	ctracer__method_hook(1, 0x1b18df5, $sk, 80);
}

probe udp_push_pending_frames = kernel.function("udp_push_pending_frames")
{
}

probe udp_push_pending_frames
{
	ctracer__method_hook(0, 0x1b1884d, $sk, 80);
}

probe udp_push_pending_frames__return = kernel.function("udp_push_pending_frames").return
{
}

probe udp_push_pending_frames__return
{
	ctracer__method_hook(1, 0x1b1884d, $sk, 80);
}

probe udp_getsockopt = kernel.function("udp_getsockopt")
{
}

probe udp_getsockopt
{
	ctracer__method_hook(0, 0x1b18741, $sk, 80);
}

probe udp_getsockopt__return = kernel.function("udp_getsockopt").return
{
}

probe udp_getsockopt__return
{
	ctracer__method_hook(1, 0x1b18741, $sk, 80);
}

probe compat_udp_getsockopt = kernel.function("compat_udp_getsockopt")
{
}

probe compat_udp_getsockopt
{
	ctracer__method_hook(0, 0x1b186cc, $sk, 80);
}

probe compat_udp_getsockopt__return = kernel.function("compat_udp_getsockopt").return
{
}

probe compat_udp_getsockopt__return
{
	ctracer__method_hook(1, 0x1b186cc, $sk, 80);
}

probe udp_lib_getsockopt = kernel.function("udp_lib_getsockopt")
{
}

probe udp_lib_getsockopt
{
	ctracer__method_hook(0, 0x1b185c8, $sk, 80);
}

probe udp_lib_getsockopt__return = kernel.function("udp_lib_getsockopt").return
{
}

probe udp_lib_getsockopt__return
{
	ctracer__method_hook(1, 0x1b185c8, $sk, 80);
}

probe udp_lib_close = kernel.function("udp_lib_close")
{
}

probe udp_lib_close
{
	ctracer__method_hook(0, 0x1b17dae, $sk, 80);
}

probe udp_lib_close__return = kernel.function("udp_lib_close").return
{
}

probe udp_lib_close__return
{
	ctracer__method_hook(1, 0x1b17dae, $sk, 80);
}

probe udp_v4_get_port = kernel.function("udp_v4_get_port")
{
}

probe udp_v4_get_port
{
	ctracer__method_hook(0, 0x1b17d6d, $sk, 80);
}

probe udp_v4_get_port__return = kernel.function("udp_v4_get_port").return
{
}

probe udp_v4_get_port__return
{
	ctracer__method_hook(1, 0x1b17d6d, $sk, 80);
}

probe udp_get_port = kernel.function("udp_get_port")
{
}

probe udp_get_port
{
	ctracer__method_hook(0, 0x1b17d1c, $sk, 80);
}

probe udp_get_port__return = kernel.function("udp_get_port").return
{
}

probe udp_get_port__return
{
	ctracer__method_hook(1, 0x1b17d1c, $sk, 80);
}

probe __udp_lib_get_port = kernel.function("__udp_lib_get_port")
{
}

probe __udp_lib_get_port
{
	ctracer__method_hook(0, 0x1b17a21, $sk, 80);
}

probe __udp_lib_get_port__return = kernel.function("__udp_lib_get_port").return
{
}

probe __udp_lib_get_port__return
{
	ctracer__method_hook(1, 0x1b17a21, $sk, 80);
}

probe udp_get_next = kernel.function("udp_get_next")
{
}

probe udp_get_next
{
	ctracer__method_hook(0, 0x1b1779d, $sk, 80);
}

probe udp_get_next__return = kernel.function("udp_get_next").return
{
}

probe udp_get_next__return
{
	ctracer__method_hook(1, 0x1b1779d, $sk, 80);
}

probe udp_lib_hash = kernel.function("udp_lib_hash")
{
}

probe udp_lib_hash
{
	ctracer__method_hook(0, 0x1b17771, $sk, 80);
}

probe udp_lib_hash__return = kernel.function("udp_lib_hash").return
{
}

probe udp_lib_hash__return
{
	ctracer__method_hook(1, 0x1b17771, $sk, 80);
}

probe udplite_v4_get_port = kernel.function("udplite_v4_get_port")
{
}

probe udplite_v4_get_port
{
	ctracer__method_hook(0, 0x1b2a7dc, $sk, 80);
}

probe udplite_v4_get_port__return = kernel.function("udplite_v4_get_port").return
{
}

probe udplite_v4_get_port__return
{
	ctracer__method_hook(1, 0x1b2a7dc, $sk, 80);
}

probe udplite_get_port = kernel.function("udplite_get_port")
{
}

probe udplite_get_port
{
	ctracer__method_hook(0, 0x1b2a774, $sk, 80);
}

probe udplite_get_port__return = kernel.function("udplite_get_port").return
{
}

probe udplite_get_port__return
{
	ctracer__method_hook(1, 0x1b2a774, $sk, 80);
}

probe udplite_sk_init = kernel.function("udplite_sk_init")
{
}

probe udplite_sk_init
{
	ctracer__method_hook(0, 0x1b2a407, $sk, 80);
}

probe udplite_sk_init__return = kernel.function("udplite_sk_init").return
{
}

probe udplite_sk_init__return
{
	ctracer__method_hook(1, 0x1b2a407, $sk, 80);
}

probe inet_sock_destruct = kernel.function("inet_sock_destruct")
{
}

probe inet_sock_destruct
{
	ctracer__method_hook(0, 0x1b73bc2, $sk, 80);
}

probe inet_sock_destruct__return = kernel.function("inet_sock_destruct").return
{
}

probe inet_sock_destruct__return
{
	ctracer__method_hook(1, 0x1b73bc2, $sk, 80);
}

probe inet_sk_rebuild_header = kernel.function("inet_sk_rebuild_header")
{
}

probe inet_sk_rebuild_header
{
	ctracer__method_hook(0, 0x1b72b59, $sk, 80);
}

probe inet_sk_rebuild_header__return = kernel.function("inet_sk_rebuild_header").return
{
}

probe inet_sk_rebuild_header__return
{
	ctracer__method_hook(1, 0x1b72b59, $sk, 80);
}

probe inet_autobind = kernel.function("inet_autobind")
{
}

probe inet_autobind
{
	ctracer__method_hook(0, 0x1b71fe9, $sk, 80);
}

probe inet_autobind__return = kernel.function("inet_autobind").return
{
}

probe inet_autobind__return
{
	ctracer__method_hook(1, 0x1b71fe9, $sk, 80);
}

probe ip_mc_drop_socket = kernel.function("ip_mc_drop_socket")
{
}

probe ip_mc_drop_socket
{
	ctracer__method_hook(0, 0x1b88993, $sk, 80);
}

probe ip_mc_drop_socket__return = kernel.function("ip_mc_drop_socket").return
{
}

probe ip_mc_drop_socket__return
{
	ctracer__method_hook(1, 0x1b88993, $sk, 80);
}

probe ip_mc_sf_allow = kernel.function("ip_mc_sf_allow")
{
}

probe ip_mc_sf_allow
{
	ctracer__method_hook(0, 0x1b881d4, $sk, 80);
}

probe ip_mc_sf_allow__return = kernel.function("ip_mc_sf_allow").return
{
}

probe ip_mc_sf_allow__return
{
	ctracer__method_hook(1, 0x1b881d4, $sk, 80);
}

probe ip_mc_gsfget = kernel.function("ip_mc_gsfget")
{
}

probe ip_mc_gsfget
{
	ctracer__method_hook(0, 0x1b88069, $sk, 80);
}

probe ip_mc_gsfget__return = kernel.function("ip_mc_gsfget").return
{
}

probe ip_mc_gsfget__return
{
	ctracer__method_hook(1, 0x1b88069, $sk, 80);
}

probe ip_mc_msfget = kernel.function("ip_mc_msfget")
{
}

probe ip_mc_msfget
{
	ctracer__method_hook(0, 0x1b87f3e, $sk, 80);
}

probe ip_mc_msfget__return = kernel.function("ip_mc_msfget").return
{
}

probe ip_mc_msfget__return
{
	ctracer__method_hook(1, 0x1b87f3e, $sk, 80);
}

probe ip_mc_msfilter = kernel.function("ip_mc_msfilter")
{
}

probe ip_mc_msfilter
{
	ctracer__method_hook(0, 0x1b87e30, $sk, 80);
}

probe ip_mc_msfilter__return = kernel.function("ip_mc_msfilter").return
{
}

probe ip_mc_msfilter__return
{
	ctracer__method_hook(1, 0x1b87e30, $sk, 80);
}

probe ip_mc_source = kernel.function("ip_mc_source")
{
}

probe ip_mc_source
{
	ctracer__method_hook(0, 0x1b87cd7, $sk, 80);
}

probe ip_mc_source__return = kernel.function("ip_mc_source").return
{
}

probe ip_mc_source__return
{
	ctracer__method_hook(1, 0x1b87cd7, $sk, 80);
}

probe ip_mc_join_group = kernel.function("ip_mc_join_group")
{
}

probe ip_mc_join_group
{
	ctracer__method_hook(0, 0x1b87bed, $sk, 80);
}

probe ip_mc_join_group__return = kernel.function("ip_mc_join_group").return
{
}

probe ip_mc_join_group__return
{
	ctracer__method_hook(1, 0x1b87bed, $sk, 80);
}

probe ip_mc_leave_group = kernel.function("ip_mc_leave_group")
{
}

probe ip_mc_leave_group
{
	ctracer__method_hook(0, 0x1b87277, $sk, 80);
}

probe ip_mc_leave_group__return = kernel.function("ip_mc_leave_group").return
{
}

probe ip_mc_leave_group__return
{
	ctracer__method_hook(1, 0x1b87277, $sk, 80);
}

probe ip_mc_leave_src = kernel.function("ip_mc_leave_src")
{
}

probe ip_mc_leave_src
{
	ctracer__method_hook(0, 0x1b85f68, $sk, 80);
}

probe ip_mc_leave_src__return = kernel.function("ip_mc_leave_src").return
{
}

probe ip_mc_leave_src__return
{
	ctracer__method_hook(1, 0x1b85f68, $sk, 80);
}

probe nl_fib_input = kernel.function("nl_fib_input")
{
}

probe nl_fib_input
{
	ctracer__method_hook(0, 0x1ba8216, $sk, 80);
}

probe nl_fib_input__return = kernel.function("nl_fib_input").return
{
}

probe nl_fib_input__return
{
	ctracer__method_hook(1, 0x1ba8216, $sk, 80);
}

probe ipmr_ioctl = kernel.function("ipmr_ioctl")
{
}

probe ipmr_ioctl
{
	ctracer__method_hook(0, 0x1bff28b, $sk, 80);
}

probe ipmr_ioctl__return = kernel.function("ipmr_ioctl").return
{
}

probe ipmr_ioctl__return
{
	ctracer__method_hook(1, 0x1bff28b, $sk, 80);
}

probe ip_mroute_setsockopt = kernel.function("ip_mroute_setsockopt")
{
}

probe ip_mroute_setsockopt
{
	ctracer__method_hook(0, 0x1bfec45, $sk, 80);
}

probe ip_mroute_setsockopt__return = kernel.function("ip_mroute_setsockopt").return
{
}

probe ip_mroute_setsockopt__return
{
	ctracer__method_hook(1, 0x1bfec45, $sk, 80);
}

probe mrtsock_destruct = kernel.function("mrtsock_destruct")
{
}

probe mrtsock_destruct
{
	ctracer__method_hook(0, 0x1bfe8ee, $sk, 80);
}

probe mrtsock_destruct__return = kernel.function("mrtsock_destruct").return
{
}

probe mrtsock_destruct__return
{
	ctracer__method_hook(1, 0x1bfe8ee, $sk, 80);
}

probe ip_mroute_getsockopt = kernel.function("ip_mroute_getsockopt")
{
}

probe ip_mroute_getsockopt
{
	ctracer__method_hook(0, 0x1bfe7b9, $sk, 80);
}

probe ip_mroute_getsockopt__return = kernel.function("ip_mroute_getsockopt").return
{
}

probe ip_mroute_getsockopt__return
{
	ctracer__method_hook(1, 0x1bfe7b9, $sk, 80);
}

probe cookie_v4_check = kernel.function("cookie_v4_check")
{
}

probe cookie_v4_check
{
	ctracer__method_hook(0, 0x1c10f7d, $sk, 80);
}

probe cookie_v4_check__return = kernel.function("cookie_v4_check").return
{
}

probe cookie_v4_check__return
{
	ctracer__method_hook(1, 0x1c10f7d, $sk, 80);
}

probe cookie_v4_init_sequence = kernel.function("cookie_v4_init_sequence")
{
}

probe cookie_v4_init_sequence
{
	ctracer__method_hook(0, 0x1c10ae4, $sk, 80);
}

probe cookie_v4_init_sequence__return = kernel.function("cookie_v4_init_sequence").return
{
}

probe cookie_v4_init_sequence__return
{
	ctracer__method_hook(1, 0x1c10ae4, $sk, 80);
}

probe bictcp_init = kernel.function("bictcp_init")
{
}

probe bictcp_init
{
	ctracer__method_hook(0, 0x1c3281d, $sk, 80);
}

probe bictcp_init__return = kernel.function("bictcp_init").return
{
}

probe bictcp_init__return
{
	ctracer__method_hook(1, 0x1c3281d, $sk, 80);
}

probe bictcp_recalc_ssthresh = kernel.function("bictcp_recalc_ssthresh")
{
}

probe bictcp_recalc_ssthresh
{
	ctracer__method_hook(0, 0x1c327d1, $sk, 80);
}

probe bictcp_recalc_ssthresh__return = kernel.function("bictcp_recalc_ssthresh").return
{
}

probe bictcp_recalc_ssthresh__return
{
	ctracer__method_hook(1, 0x1c327d1, $sk, 80);
}

probe bictcp_cong_avoid = kernel.function("bictcp_cong_avoid")
{
}

probe bictcp_cong_avoid
{
	ctracer__method_hook(0, 0x1c325be, $sk, 80);
}

probe bictcp_cong_avoid__return = kernel.function("bictcp_cong_avoid").return
{
}

probe bictcp_cong_avoid__return
{
	ctracer__method_hook(1, 0x1c325be, $sk, 80);
}

probe bictcp_state = kernel.function("bictcp_state")
{
}

probe bictcp_state
{
	ctracer__method_hook(0, 0x1c3244d, $sk, 80);
}

probe bictcp_state__return = kernel.function("bictcp_state").return
{
}

probe bictcp_state__return
{
	ctracer__method_hook(1, 0x1c3244d, $sk, 80);
}

probe bictcp_undo_cwnd = kernel.function("bictcp_undo_cwnd")
{
}

probe bictcp_undo_cwnd
{
	ctracer__method_hook(0, 0x1c323f8, $sk, 80);
}

probe bictcp_undo_cwnd__return = kernel.function("bictcp_undo_cwnd").return
{
}

probe bictcp_undo_cwnd__return
{
	ctracer__method_hook(1, 0x1c323f8, $sk, 80);
}

probe bictcp_acked = kernel.function("bictcp_acked")
{
}

probe bictcp_acked
{
	ctracer__method_hook(0, 0x1c32351, $sk, 80);
}

probe bictcp_acked__return = kernel.function("bictcp_acked").return
{
}

probe bictcp_acked__return
{
	ctracer__method_hook(1, 0x1c32351, $sk, 80);
}

probe cipso_v4_sock_setattr = kernel.function("cipso_v4_sock_setattr")
{
}

probe cipso_v4_sock_setattr
{
	ctracer__method_hook(0, 0x1c442c9, $sk, 80);
}

probe cipso_v4_sock_setattr__return = kernel.function("cipso_v4_sock_setattr").return
{
}

probe cipso_v4_sock_setattr__return
{
	ctracer__method_hook(1, 0x1c442c9, $sk, 80);
}

probe cipso_v4_sock_getattr = kernel.function("cipso_v4_sock_getattr")
{
}

probe cipso_v4_sock_getattr
{
	ctracer__method_hook(0, 0x1c43948, $sk, 80);
}

probe cipso_v4_sock_getattr__return = kernel.function("cipso_v4_sock_getattr").return
{
}

probe cipso_v4_sock_getattr__return
{
	ctracer__method_hook(1, 0x1c43948, $sk, 80);
}

probe xfrm4_udp_encap_rcv = kernel.function("xfrm4_udp_encap_rcv")
{
}

probe xfrm4_udp_encap_rcv
{
	ctracer__method_hook(0, 0x1c76a55, $sk, 80);
}

probe xfrm4_udp_encap_rcv__return = kernel.function("xfrm4_udp_encap_rcv").return
{
}

probe xfrm4_udp_encap_rcv__return
{
	ctracer__method_hook(1, 0x1c76a55, $sk, 80);
}

probe __xfrm_policy_check = kernel.function("__xfrm_policy_check")
{
}

probe __xfrm_policy_check
{
	ctracer__method_hook(0, 0x1c9d788, $sk, 80);
}

probe __xfrm_policy_check__return = kernel.function("__xfrm_policy_check").return
{
}

probe __xfrm_policy_check__return
{
	ctracer__method_hook(1, 0x1c9d788, $sk, 80);
}

probe __xfrm_sk_clone_policy = kernel.function("__xfrm_sk_clone_policy")
{
}

probe __xfrm_sk_clone_policy
{
	ctracer__method_hook(0, 0x1c9be3a, $sk, 80);
}

probe __xfrm_sk_clone_policy__return = kernel.function("__xfrm_sk_clone_policy").return
{
}

probe __xfrm_sk_clone_policy__return
{
	ctracer__method_hook(1, 0x1c9be3a, $sk, 80);
}

probe xfrm_sk_policy_insert = kernel.function("xfrm_sk_policy_insert")
{
}

probe xfrm_sk_policy_insert
{
	ctracer__method_hook(0, 0x1c9bbc0, $sk, 80);
}

probe xfrm_sk_policy_insert__return = kernel.function("xfrm_sk_policy_insert").return
{
}

probe xfrm_sk_policy_insert__return
{
	ctracer__method_hook(1, 0x1c9bbc0, $sk, 80);
}

probe xfrm_lookup = kernel.function("xfrm_lookup")
{
}

probe xfrm_lookup
{
	ctracer__method_hook(0, 0x1c9b72a, $sk, 80);
}

probe xfrm_lookup__return = kernel.function("xfrm_lookup").return
{
}

probe xfrm_lookup__return
{
	ctracer__method_hook(1, 0x1c9b72a, $sk, 80);
}

probe __xfrm_lookup = kernel.function("__xfrm_lookup")
{
}

probe __xfrm_lookup
{
	ctracer__method_hook(0, 0x1c9ac3a, $sk, 80);
}

probe __xfrm_lookup__return = kernel.function("__xfrm_lookup").return
{
}

probe __xfrm_lookup__return
{
	ctracer__method_hook(1, 0x1c9ac3a, $sk, 80);
}

probe xfrm_sk_policy_lookup = kernel.function("xfrm_sk_policy_lookup")
{
}

probe xfrm_sk_policy_lookup
{
	ctracer__method_hook(0, 0x1c994dd, $sk, 80);
}

probe xfrm_sk_policy_lookup__return = kernel.function("xfrm_sk_policy_lookup").return
{
}

probe xfrm_sk_policy_lookup__return
{
	ctracer__method_hook(1, 0x1c994dd, $sk, 80);
}

probe xfrm_user_policy = kernel.function("xfrm_user_policy")
{
}

probe xfrm_user_policy
{
	ctracer__method_hook(0, 0x1cb0c56, $sk, 80);
}

probe xfrm_user_policy__return = kernel.function("xfrm_user_policy").return
{
}

probe xfrm_user_policy__return
{
	ctracer__method_hook(1, 0x1cb0c56, $sk, 80);
}

probe xfrm_compile_policy = kernel.function("xfrm_compile_policy")
{
}

probe xfrm_compile_policy
{
	ctracer__method_hook(0, 0x1ceed18, $sk, 80);
}

probe xfrm_compile_policy__return = kernel.function("xfrm_compile_policy").return
{
}

probe xfrm_compile_policy__return
{
	ctracer__method_hook(1, 0x1ceed18, $sk, 80);
}

probe xfrm_netlink_rcv = kernel.function("xfrm_netlink_rcv")
{
}

probe xfrm_netlink_rcv
{
	ctracer__method_hook(0, 0x1cebaa0, $sk, 80);
}

probe xfrm_netlink_rcv__return = kernel.function("xfrm_netlink_rcv").return
{
}

probe xfrm_netlink_rcv__return
{
	ctracer__method_hook(1, 0x1cebaa0, $sk, 80);
}

probe unix_write_space = kernel.function("unix_write_space")
{
}

probe unix_write_space
{
	ctracer__method_hook(0, 0x1d02bd1, $sk, 80);
}

probe unix_write_space__return = kernel.function("unix_write_space").return
{
}

probe unix_write_space__return
{
	ctracer__method_hook(1, 0x1d02bd1, $sk, 80);
}

probe unix_sock_destructor = kernel.function("unix_sock_destructor")
{
}

probe unix_sock_destructor
{
	ctracer__method_hook(0, 0x1d012f2, $sk, 80);
}

probe unix_sock_destructor__return = kernel.function("unix_sock_destructor").return
{
}

probe unix_sock_destructor__return
{
	ctracer__method_hook(1, 0x1d012f2, $sk, 80);
}

probe unix_release_sock = kernel.function("unix_release_sock")
{
}

probe unix_release_sock
{
	ctracer__method_hook(0, 0x1cffdf2, $sk, 80);
}

probe unix_release_sock__return = kernel.function("unix_release_sock").return
{
}

probe unix_release_sock__return
{
	ctracer__method_hook(1, 0x1cffdf2, $sk, 80);
}

probe unix_wait_for_peer = kernel.function("unix_wait_for_peer")
{
}

probe unix_wait_for_peer
{
	ctracer__method_hook(0, 0x1cff27f, $other, 80);
}

probe unix_wait_for_peer__return = kernel.function("unix_wait_for_peer").return
{
}

probe unix_wait_for_peer__return
{
	ctracer__method_hook(1, 0x1cff27f, $other, 80);
}

probe unix_dgram_disconnected = kernel.function("unix_dgram_disconnected")
{
}

probe unix_dgram_disconnected
{
	ctracer__method_hook(0, 0x1cff1f8, $sk, 80);
}

probe unix_dgram_disconnected__return = kernel.function("unix_dgram_disconnected").return
{
}

probe unix_dgram_disconnected__return
{
	ctracer__method_hook(1, 0x1cff1f8, $sk, 80);
}

probe __unix_remove_socket = kernel.function("__unix_remove_socket")
{
}

probe __unix_remove_socket
{
	ctracer__method_hook(0, 0x1cfef42, $sk, 80);
}

probe __unix_remove_socket__return = kernel.function("__unix_remove_socket").return
{
}

probe __unix_remove_socket__return
{
	ctracer__method_hook(1, 0x1cfef42, $sk, 80);
}

probe unix_copy_addr = kernel.function("unix_copy_addr")
{
}

probe unix_copy_addr
{
	ctracer__method_hook(0, 0x1cfed18, $sk, 80);
}

probe unix_copy_addr__return = kernel.function("unix_copy_addr").return
{
}

probe unix_copy_addr__return
{
	ctracer__method_hook(1, 0x1cfed18, $sk, 80);
}

probe __unix_insert_socket = kernel.function("__unix_insert_socket")
{
}

probe __unix_insert_socket
{
	ctracer__method_hook(0, 0x1cfec51, $sk, 80);
}

probe __unix_insert_socket__return = kernel.function("__unix_insert_socket").return
{
}

probe __unix_insert_socket__return
{
	ctracer__method_hook(1, 0x1cfec51, $sk, 80);
}

probe unix_state_double_lock = kernel.function("unix_state_double_lock")
{
}

probe unix_state_double_lock
{
	ctracer__method_hook(0, 0x1cfec0f, $sk1, 80);
}

probe unix_state_double_lock__return = kernel.function("unix_state_double_lock").return
{
}

probe unix_state_double_lock__return
{
	ctracer__method_hook(1, 0x1cfec0f, $sk1, 80);
}

probe unix_state_double_unlock = kernel.function("unix_state_double_unlock")
{
}

probe unix_state_double_unlock
{
	ctracer__method_hook(0, 0x1cfeb70, $sk1, 80);
}

probe unix_state_double_unlock__return = kernel.function("unix_state_double_unlock").return
{
}

probe unix_state_double_unlock__return
{
	ctracer__method_hook(1, 0x1cfeb70, $sk1, 80);
}

probe unix_peer_get = kernel.function("unix_peer_get")
{
}

probe unix_peer_get
{
	ctracer__method_hook(0, 0x1cfe965, $s, 80);
}

probe unix_peer_get__return = kernel.function("unix_peer_get").return
{
}

probe unix_peer_get__return
{
	ctracer__method_hook(1, 0x1cfe965, $s, 80);
}

probe next_unix_socket = kernel.function("next_unix_socket")
{
}

probe next_unix_socket
{
	ctracer__method_hook(0, 0x1cfe6c4, $s, 80);
}

probe next_unix_socket__return = kernel.function("next_unix_socket").return
{
}

probe next_unix_socket__return
{
	ctracer__method_hook(1, 0x1cfe6c4, $s, 80);
}

probe inc_inflight_move_tail = kernel.function("inc_inflight_move_tail")
{
}

probe inc_inflight_move_tail
{
	ctracer__method_hook(0, 0x1d12161, $sk, 80);
}

probe inc_inflight_move_tail__return = kernel.function("inc_inflight_move_tail").return
{
}

probe inc_inflight_move_tail__return
{
	ctracer__method_hook(1, 0x1d12161, $sk, 80);
}

probe inc_inflight = kernel.function("inc_inflight")
{
}

probe inc_inflight
{
	ctracer__method_hook(0, 0x1d11e63, $sk, 80);
}

probe inc_inflight__return = kernel.function("inc_inflight").return
{
}

probe inc_inflight__return
{
	ctracer__method_hook(1, 0x1d11e63, $sk, 80);
}

probe scan_children = kernel.function("scan_children")
{
}

probe scan_children
{
	ctracer__method_hook(0, 0x1d11c9b, $x, 80);
}

probe scan_children__return = kernel.function("scan_children").return
{
}

probe scan_children__return
{
	ctracer__method_hook(1, 0x1d11c9b, $x, 80);
}

probe scan_inflight = kernel.function("scan_inflight")
{
}

probe scan_inflight
{
	ctracer__method_hook(0, 0x1d11afe, $x, 80);
}

probe scan_inflight__return = kernel.function("scan_inflight").return
{
}

probe scan_inflight__return
{
	ctracer__method_hook(1, 0x1d11afe, $x, 80);
}

probe dec_inflight = kernel.function("dec_inflight")
{
}

probe dec_inflight
{
	ctracer__method_hook(0, 0x1d11ab5, $sk, 80);
}

probe dec_inflight__return = kernel.function("dec_inflight").return
{
}

probe dec_inflight__return
{
	ctracer__method_hook(1, 0x1d11ab5, $sk, 80);
}

probe inet6_hash_connect = kernel.function("inet6_hash_connect")
{
}

probe inet6_hash_connect
{
	ctracer__method_hook(0, 0x1d4e453, $sk, 80);
}

probe inet6_hash_connect__return = kernel.function("inet6_hash_connect").return
{
}

probe inet6_hash_connect__return
{
	ctracer__method_hook(1, 0x1d4e453, $sk, 80);
}

probe __inet6_hash = kernel.function("__inet6_hash")
{
}

probe __inet6_hash
{
	ctracer__method_hook(0, 0x1d4e0aa, $sk, 80);
}

probe __inet6_hash__return = kernel.function("__inet6_hash").return
{
}

probe __inet6_hash__return
{
	ctracer__method_hook(1, 0x1d4e0aa, $sk, 80);
}

probe __inet6_check_established = kernel.function("__inet6_check_established")
{
}

probe __inet6_check_established
{
	ctracer__method_hook(0, 0x1d4d6a7, $sk, 80);
}

probe __inet6_check_established__return = kernel.function("__inet6_check_established").return
{
}

probe __inet6_check_established__return
{
	ctracer__method_hook(1, 0x1d4d6a7, $sk, 80);
}

probe packet_sock_destruct = kernel.function("packet_sock_destruct")
{
}

probe packet_sock_destruct
{
	ctracer__method_hook(0, 0x1d60847, $sk, 80);
}

probe packet_sock_destruct__return = kernel.function("packet_sock_destruct").return
{
}

probe packet_sock_destruct__return
{
	ctracer__method_hook(1, 0x1d60847, $sk, 80);
}

probe packet_set_ring = kernel.function("packet_set_ring")
{
}

probe packet_set_ring
{
	ctracer__method_hook(0, 0x1d5e3bd, $sk, 80);
}

probe packet_set_ring__return = kernel.function("packet_set_ring").return
{
}

probe packet_set_ring__return
{
	ctracer__method_hook(1, 0x1d5e3bd, $sk, 80);
}

probe packet_do_bind = kernel.function("packet_do_bind")
{
}

probe packet_do_bind
{
	ctracer__method_hook(0, 0x1d5e150, $sk, 80);
}

probe packet_do_bind__return = kernel.function("packet_do_bind").return
{
}

probe packet_do_bind__return
{
	ctracer__method_hook(1, 0x1d5e150, $sk, 80);
}

probe netlbl_sock_setattr = kernel.function("netlbl_sock_setattr")
{
}

probe netlbl_sock_setattr
{
	ctracer__method_hook(0, 0x1d8b6ca, $sk, 80);
}

probe netlbl_sock_setattr__return = kernel.function("netlbl_sock_setattr").return
{
}

probe netlbl_sock_setattr__return
{
	ctracer__method_hook(1, 0x1d8b6ca, $sk, 80);
}

probe netlbl_sock_getattr = kernel.function("netlbl_sock_getattr")
{
}

probe netlbl_sock_getattr
{
	ctracer__method_hook(0, 0x1d8b674, $sk, 80);
}

probe netlbl_sock_getattr__return = kernel.function("netlbl_sock_getattr").return
{
}

probe netlbl_sock_getattr__return
{
	ctracer__method_hook(1, 0x1d8b674, $sk, 80);
}