From: Remi Gacogne Date: Wed, 1 Jun 2016 12:57:18 +0000 (+0200) Subject: dnsdist: Add eBPF source address v4/v6 and qname filtering X-Git-Tag: auth-4.0.0-rc1~18^2~2 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=87b515ed042fc042df83e8601f8b2a36a462a32c;p=pdns dnsdist: Add eBPF source address v4/v6 and qname filtering --- diff --git a/ext/libbpf/libbpf.h b/ext/libbpf/libbpf.h new file mode 100644 index 000000000..aff1630a4 --- /dev/null +++ b/ext/libbpf/libbpf.h @@ -0,0 +1,210 @@ +/* eBPF mini library */ +#ifndef __LIBBPF_H +#define __LIBBPF_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct bpf_insn; + +int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size, + int max_entries); +int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags); +int bpf_lookup_elem(int fd, void *key, void *value); +int bpf_delete_elem(int fd, void *key); +int bpf_get_next_key(int fd, void *key, void *next_key); + +int bpf_prog_load(enum bpf_prog_type prog_type, + const struct bpf_insn *insns, int insn_len, + const char *license, int kern_version); + +int bpf_obj_pin(int fd, const char *pathname); +int bpf_obj_get(const char *pathname); + +#define LOG_BUF_SIZE 65536 +extern char bpf_log_buf[LOG_BUF_SIZE]; + +/* ALU ops on registers, bpf_add|sub|...: dst_reg += src_reg */ + +#define BPF_ALU64_REG(OP, DST, SRC) \ + ((struct bpf_insn) { \ + .code = BPF_ALU64 | BPF_OP(OP) | BPF_X, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = 0, \ + .imm = 0 }) + +#define BPF_ALU32_REG(OP, DST, SRC) \ + ((struct bpf_insn) { \ + .code = BPF_ALU | BPF_OP(OP) | BPF_X, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = 0, \ + .imm = 0 }) + +/* ALU ops on immediates, bpf_add|sub|...: dst_reg += imm32 */ + +#define BPF_ALU64_IMM(OP, DST, IMM) \ + ((struct bpf_insn) { \ + .code = BPF_ALU64 | BPF_OP(OP) | BPF_K, \ + .dst_reg = DST, \ + .src_reg = 0, \ + .off = 0, \ + .imm = IMM }) + +#define BPF_ALU32_IMM(OP, DST, IMM) \ + ((struct bpf_insn) { \ + .code = BPF_ALU | BPF_OP(OP) | BPF_K, \ + .dst_reg = DST, \ + .src_reg = 0, \ + .off = 0, \ + .imm = IMM }) + +/* Short form of mov, dst_reg = src_reg */ + +#define BPF_MOV64_REG(DST, SRC) \ + ((struct bpf_insn) { \ + .code = BPF_ALU64 | BPF_MOV | BPF_X, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = 0, \ + .imm = 0 }) + +#define BPF_MOV32_REG(DST, SRC) \ + ((struct bpf_insn) { \ + .code = BPF_ALU | BPF_MOV | BPF_X, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = 0, \ + .imm = 0 }) + +/* Short form of mov, dst_reg = imm32 */ + +#define BPF_MOV64_IMM(DST, IMM) \ + ((struct bpf_insn) { \ + .code = BPF_ALU64 | BPF_MOV | BPF_K, \ + .dst_reg = DST, \ + .src_reg = 0, \ + .off = 0, \ + .imm = IMM }) + +/* BPF_LD_IMM64 macro encodes single 'load 64-bit immediate' insn */ +#define BPF_LD_IMM64(DST, IMM) \ + BPF_LD_IMM64_RAW(DST, 0, IMM) + +#define BPF_LD_IMM64_RAW(DST, SRC, IMM) \ + ((struct bpf_insn) { \ + .code = BPF_LD | BPF_DW | BPF_IMM, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = 0, \ + .imm = (__u32) (IMM) }), \ + ((struct bpf_insn) { \ + .code = 0, /* zero is reserved opcode */ \ + .dst_reg = 0, \ + .src_reg = 0, \ + .off = 0, \ + .imm = ((__u64) (IMM)) >> 32 }) + +#ifndef BPF_PSEUDO_MAP_FD +# define BPF_PSEUDO_MAP_FD 1 +#endif + +/* pseudo BPF_LD_IMM64 insn used to refer to process-local map_fd */ +#define BPF_LD_MAP_FD(DST, MAP_FD) \ + BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD) + + +/* Direct packet access, R0 = *(uint *) (skb->data + imm32) */ + +#define BPF_LD_ABS(SIZE, IMM) \ + ((struct bpf_insn) { \ + .code = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS, \ + .dst_reg = 0, \ + .src_reg = 0, \ + .off = 0, \ + .imm = IMM }) + +/* Memory load, dst_reg = *(uint *) (src_reg + off16) */ + +#define BPF_LDX_MEM(SIZE, DST, SRC, OFF) \ + ((struct bpf_insn) { \ + .code = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = OFF, \ + .imm = 0 }) + +/* Memory store, *(uint *) (dst_reg + off16) = src_reg */ + +#define BPF_STX_MEM(SIZE, DST, SRC, OFF) \ + ((struct bpf_insn) { \ + .code = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = OFF, \ + .imm = 0 }) + +/* Memory store, *(uint *) (dst_reg + off16) = imm32 */ + +#define BPF_ST_MEM(SIZE, DST, OFF, IMM) \ + ((struct bpf_insn) { \ + .code = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM, \ + .dst_reg = DST, \ + .src_reg = 0, \ + .off = OFF, \ + .imm = IMM }) + +/* Conditional jumps against registers, if (dst_reg 'op' src_reg) goto pc + off16 */ + +#define BPF_JMP_REG(OP, DST, SRC, OFF) \ + ((struct bpf_insn) { \ + .code = BPF_JMP | BPF_OP(OP) | BPF_X, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = OFF, \ + .imm = 0 }) + +/* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */ + +#define BPF_JMP_IMM(OP, DST, IMM, OFF) \ + ((struct bpf_insn) { \ + .code = BPF_JMP | BPF_OP(OP) | BPF_K, \ + .dst_reg = DST, \ + .src_reg = 0, \ + .off = OFF, \ + .imm = IMM }) + +/* Raw code statement block */ + +#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM) \ + ((struct bpf_insn) { \ + .code = CODE, \ + .dst_reg = DST, \ + .src_reg = SRC, \ + .off = OFF, \ + .imm = IMM }) + +/* Program exit */ + +#define BPF_EXIT_INSN() \ + ((struct bpf_insn) { \ + .code = BPF_JMP | BPF_EXIT, \ + .dst_reg = 0, \ + .src_reg = 0, \ + .off = 0, \ + .imm = 0 }) + +/* create RAW socket and bind to interface 'name' */ +int open_raw_sock(const char *name); + +struct perf_event_attr; +int perf_event_open(struct perf_event_attr *attr, int pid, int cpu, + int group_fd, unsigned long flags); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/m4/pdns_with_ebpf.m4 b/m4/pdns_with_ebpf.m4 new file mode 100644 index 000000000..54c04854a --- /dev/null +++ b/m4/pdns_with_ebpf.m4 @@ -0,0 +1,22 @@ +AC_DEFUN([PDNS_WITH_EBPF],[ + AC_MSG_CHECKING([if we have eBPF support]) + AC_ARG_WITH([ebpf], + AS_HELP_STRING([--with-ebpf],[enable eBPF support @<:@default=auto@:>@]), + [with_ebpf=$withval], + [with_ebpf=auto], + ) + AC_MSG_RESULT([$with_ebpf]) + + AS_IF([test "x$with_ebpf" != "xno"], [ + AS_IF([test "x$with_ebpf" = "xyes" -o "x$with_ebpf" = "xauto"], [ + AC_CHECK_HEADERS([linux/bpf.h], bpf_headers=yes, bpf_headers=no) + ]) + ]) + AS_IF([test "x$with_ebpf" = "xyes"], [ + AS_IF([test x"$bpf_headers" = "no"], [ + AC_MSG_ERROR([EBPF support requested but required eBPF headers were not found]) + ]) + ]) + AM_CONDITIONAL([HAVE_EBPF], [test x"$bpf_headers" = "xyes" ]) + AS_IF([test x"$bpf_headers" = "xyes" ], [AC_DEFINE([HAVE_EBPF], [1], [Define if using eBPF.])]) +]) diff --git a/pdns/README-dnsdist.md b/pdns/README-dnsdist.md index 6a5f00ebd..d5d5c4dd7 100644 --- a/pdns/README-dnsdist.md +++ b/pdns/README-dnsdist.md @@ -1027,6 +1027,80 @@ move the address check on `dnsdist`'s side: > addAction(AndRule({OpcodeRule(DNSOpcode.Notify), NotRule(makeRule("192.168.1.0/24"))}), RCodeAction(dnsdist.REFUSED)) ``` +eBPF Socket Filtering +--------------------- +`dnsdist` can use eBPF socket filtering on recent Linux kernels (4.1+) built with eBPF +support (`CONFIG_BPF`, `CONFIG_BPF_SYSCALL`, ideally `CONFIG_BPF_JIT`). +This feature might require an increase of the memory limit associated to socket, via +`the sysctl` setting `net.core.optmem_max`. When attaching an eBPF program to a socket, +the size of the program is checked against this limit, and the default value might not be +enough. Large map sizes might also require an increase of `RLIMIT_MEMLOCK`. + +This feature allows `dnsdist` to ask the kernel to discard incoming packets in kernel-space +instead of them being copied to userspace just to be dropped, thus being a lot of faster. + +The BPF filter can be used to block incoming queries manually: + +``` +> bpf = newBPFFilter(1024, 1024, 1024) +> bpf:attachToAllBinds() +> bpf:block(ComboAddress("2001:DB8::42")) +> bpf:blockQName(newDNSName("evildomain.com"), 255) +> bpf:getStats() +[2001:DB8::42]: 0 +evildomain.com. 255: 0 +> bpf:unblock(ComboAddress("2001:DB8::42")) +> bpf:unblockQName(newDNSName("evildomain.com"), 255) +> bpf:getStats() +> +``` + +The `blockQName()` method can be used to block queries based on the exact qname supplied, +and an optional qtype. Using the 255 (ANY) qtype will block all queries for the qname, +regardless of the qtype. Contrary to source address filtering, qname filtering only works +over UDP. TCP qname filtering can be done the usual way: + +``` +> addAction(AndRule({TCPRule(true), makeRule("evildomain.com")}), DropAction()) +``` + +The `attachToAllBinds()` method attach the filter to every existing binds at runtime, +but it's also possible to define a default BPF filter at configuration time, so that +it's automatically attached to every binds: + +``` +bpf = newBPFFilter(1024, 1024, 1024) +setDefaultBPFFilter(bpf) +``` + +Finally, it's also possible to attach it to only specific binds at runtime: + +``` +> bpf = newBPFFilter(1024, 1024, 1024) +> showBinds() +# Address Protocol Queries +0 [::]:53 UDP 0 +1 [::]:53 TCP 0 +> bd = getBind(0) +> bd:attachFilter(bpf) +``` + +`dnsdist` also supports adding dynamic, expiring blocks to a BPF filter: + +``` +bpf = newBPFFilter(1024, 1024, 1024) +setDefaultBPFFilter(bpf) +dbpf = newDynBPFFilter(bpf) +function maintenance() + addBPFFilterDynBlocks(exceedQRate(20, 10), dbpf, 60) + dbpf:purgeExpired() +end +``` + +This will dynamically block all hosts that exceeded 20 queries/s as measured +over the past 10 seconds, and the dynamic block will last for 60 seconds. + +Arch and Fedora Core 23 are known to support this feature. All functions and types ----------------------- @@ -1060,6 +1134,11 @@ Here are all functions: * `addACL(netmask)`: add to the ACL set who can use this server * `setACL({netmask, netmask})`: replace the ACL set with these netmasks. Use `setACL({})` to reset the list, meaning no one can use us * `showACL()`: show our ACL set + * ClientState related: + * function `showBinds()`: list every local binds + * function `getBind(n)`: return the corresponding `ClientState` object + * member `attachFilter(BPFFilter)`: attach a BPF Filter to this bind + * member `toString()`: print the address this bind listens to * Network related: * `addLocal(netmask, [false], [false])`: add to addresses we listen on. Second optional parameter sets TCP/IP or not. Third optional parameter sets SO_REUSEPORT when available. * `setLocal(netmask, [false], [false])`: reset list of addresses we listen on to this address. Second optional parameter sets TCP/IP or not. Third optional parameter sets SO_REUSEPORT when available. @@ -1212,6 +1291,7 @@ instantiate a server with additional parameters * `clearDynBlocks()`: clear all dynamic blocks * `showDynBlocks()`: show dynamic blocks in force * `addDynBlocks(addresses, message[, seconds])`: block the set of addresses with message `msg`, for `seconds` seconds (10 by default) + * `addBPFFilterDynBlocks(addresses, DynBPFFilter[, seconds])`: block the set of addresses using the supplied BPF Filter, for `seconds` seconds (10 by default) * `exceedServFails(rate, seconds)`: get set of addresses that exceed `rate` servails/s over `seconds` seconds * `exceedNXDOMAINs(rate, seconds)`: get set of addresses that exceed `rate` NXDOMAIN/s over `seconds` seconds * `exceedRespByterate(rate, seconds)`: get set of addresses that exeeded `rate` bytes/s answers over `seconds` seconds @@ -1289,6 +1369,19 @@ instantiate a server with additional parameters * `generateDNSCryptCertificate("/path/to/providerPrivate.key", "/path/to/resolver.cert", "/path/to/resolver.key", serial, validFrom, validUntil):` generate a new resolver private key and related certificate, valid from the `validFrom` timestamp until the `validUntil` one, signed with the provider private key * `printDNSCryptProviderFingerprint("/path/to/providerPublic.key")`: display the fingerprint of the provided resolver public key * `showDNSCryptBinds():`: display the currently configured DNSCrypt binds + * BPFFilter related: + * function `newBPFFilter(maxV4, maxV6, maxQNames)`: return a new eBPF socket filter with a maximum of maxV4 IPv4, maxV6 IPv6 and maxQNames qname entries in the block tables + * function `setDefaultBPFFilter(BPFFilter)`: when used at configuration time, the corresponding BPFFilter will be attached to every binds + * member `attachToAllBinds()`: attach this filter to every binds already defined. This is the run-time equivalent of `setDefaultBPFFilter(bpf)` + * member `block(ComboAddress)`: block this address + * member `blockQName(DNSName [, qtype=255])`: block queries for this exact qname. An optional qtype can be used, default to 255 + * member `getStats()`: print the block tables + * member `unblock(ComboAddress)`: unblock this address + * member `unblockQName(DNSName [, qtype=255])`: remove this qname from the block list + * DynBPFFilter related: + * function `newDynBPFFilter(BPFFilter)`: return a new DynBPFFilter object using this BPF Filter + * member `block(ComboAddress[, seconds]): add this address to the underlying BPF Filter for `seconds` seconds (default to 10 seconds) + * member `purgeExpired()`: remove expired entries * RemoteLogger related: * `newRemoteLogger(address:port [, timeout=2, maxQueuedEntries=100, reconnectWaitTime=1])`: create a Remote Logger object, to use with `RemoteLogAction()` and `RemoteLogResponseAction()` diff --git a/pdns/bpf-filter.cc b/pdns/bpf-filter.cc new file mode 100644 index 000000000..f2e9bd8eb --- /dev/null +++ b/pdns/bpf-filter.cc @@ -0,0 +1,378 @@ +#include "bpf-filter.hh" + +#ifdef HAVE_EBPF + +#include +#include + +#include "ext/libbpf/libbpf.h" + +static __u64 ptr_to_u64(void *ptr) +{ + return (__u64) (unsigned long) ptr; +} + +int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size, + int max_entries) +{ + union bpf_attr attr = { 0 }; + attr.map_type = map_type; + attr.key_size = key_size; + attr.value_size = value_size; + attr.max_entries = max_entries; + return syscall(SYS_bpf, BPF_MAP_CREATE, &attr, sizeof(attr)); +} + +int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags) +{ + union bpf_attr attr = { 0 }; + attr.map_fd = fd; + attr.key = ptr_to_u64(key); + attr.value = ptr_to_u64(value); + attr.flags = flags; + return syscall(SYS_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr)); +} + +int bpf_lookup_elem(int fd, void *key, void *value) +{ + union bpf_attr attr = { 0 }; + attr.map_fd = fd; + attr.key = ptr_to_u64(key); + attr.value = ptr_to_u64(value); + return syscall(SYS_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr)); +} + +int bpf_delete_elem(int fd, void *key) +{ + union bpf_attr attr = { 0 }; + attr.map_fd = fd; + attr.key = ptr_to_u64(key); + return syscall(SYS_bpf, BPF_MAP_DELETE_ELEM, &attr, sizeof(attr)); +} + +int bpf_get_next_key(int fd, void *key, void *next_key) +{ + union bpf_attr attr = { 0 }; + attr.map_fd = fd; + attr.key = ptr_to_u64(key); + attr.next_key = ptr_to_u64(next_key); + return syscall(SYS_bpf, BPF_MAP_GET_NEXT_KEY, &attr, sizeof(attr)); +} + +int bpf_prog_load(enum bpf_prog_type prog_type, + const struct bpf_insn *insns, int prog_len, + const char *license, int kern_version) +{ + char log_buf[65535]; + union bpf_attr attr = { 0 }; + attr.prog_type = prog_type; + attr.insns = ptr_to_u64((void *) insns); + attr.insn_cnt = prog_len / sizeof(struct bpf_insn); + attr.license = ptr_to_u64((void *) license); + attr.log_buf = ptr_to_u64(log_buf); + attr.log_size = sizeof(log_buf); + attr.log_level = 1; + /* assign one field outside of struct init to make sure any + * padding is zero initialized + */ + attr.kern_version = kern_version; + + long res = syscall(SYS_bpf, BPF_PROG_LOAD, &attr, sizeof(attr)); + if (res == -1) { + if (errno == ENOSPC) { + /* not enough space in the log buffer */ + attr.log_level = 0; + attr.log_size = 0; + attr.log_buf = ptr_to_u64(nullptr); + res = syscall(SYS_bpf, BPF_PROG_LOAD, &attr, sizeof(attr)); + if (res != -1) { + return res; + } + } + throw std::runtime_error("Error loading BPF program: (" + std::string(strerror(errno)) + "):\n" + std::string(log_buf)); + } + return res; +} + +struct KeyV6 +{ + uint8_t src[16]; +}; + +struct QNameKey +{ + uint8_t qname[255]; +}; + +struct QNameValue +{ + uint64_t counter; + uint16_t qtype; +}; + +BPFFilter::BPFFilter(uint32_t maxV4Addresses, uint32_t maxV6Addresses, uint32_t maxQNames): d_maxV4(maxV4Addresses), d_maxV6(maxV6Addresses), d_maxQNames(maxQNames) +{ + d_v4map = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(uint32_t), sizeof(uint64_t), (int) maxV4Addresses); + if (d_v4map == -1) { + throw std::runtime_error("Error creating a BPF v4 map of size " + std::to_string(maxV4Addresses) + ": " + std::string(strerror(errno))); + } + + d_v6map = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(struct KeyV6), sizeof(uint64_t), (int) maxV6Addresses); + if (d_v6map == -1) { + throw std::runtime_error("Error creating a BPF v6 map of size " + std::to_string(maxV6Addresses) + ": " + std::string(strerror(errno))); + } + + d_qnamemap = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(struct QNameKey), sizeof(struct QNameValue), (int) maxQNames); + if (d_qnamemap == -1) { + throw std::runtime_error("Error creating a BPF qname map of size " + std::to_string(maxQNames) + ": " + std::string(strerror(errno))); + } + struct bpf_insn filter[] = { +#include "bpf-filter.ebpf" + }; + + d_filter = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, + filter, + sizeof(filter), + "GPL", + 0); + + if (d_filter == -1) { + throw std::runtime_error("Error loading BPF filter: " + std::string(strerror(errno))); + } +} + +BPFFilter::~BPFFilter() +{ + if (d_filter != -1) { + close(d_filter); + } + if (d_v4map != -1) { + close(d_v4map); + } + if (d_v6map != -1) { + close(d_v6map); + } + if (d_qnamemap != -1) { + close(d_qnamemap); + } +} + +void BPFFilter::addSocket(int sock) +{ + int res = setsockopt(sock, SOL_SOCKET, SO_ATTACH_BPF, &d_filter, sizeof(d_filter)); + + if (res != 0) { + throw std::runtime_error("Error attaching BPF filter to this socket: " + std::string(strerror(errno))); + } +} + +void BPFFilter::block(const ComboAddress& addr) +{ + std::unique_lock lock(d_mutex); + + uint64_t counter = 0; + int res = 0; + if (addr.sin4.sin_family == AF_INET) { + uint32_t key = htonl(addr.sin4.sin_addr.s_addr); + if (d_v4Count >= d_maxV4) { + throw std::runtime_error("Table full when trying to block " + addr.toString()); + } + + res = bpf_lookup_elem(d_v4map, &key, &counter); + if (res != -1) { + throw std::runtime_error("Trying to block an already blocked address: " + addr.toString()); + } + + res = bpf_update_elem(d_v4map, &key, &counter, 0); + if (res == 0) { + d_v4Count++; + } + } + else if (addr.sin4.sin_family == AF_INET6) { + uint8_t key[16]; + static_assert(sizeof(addr.sin6.sin6_addr.s6_addr) == sizeof(key), "POSIX mandates s6_addr to be an array of 16 uint8_t"); + for (size_t idx = 0; idx < sizeof(key); idx++) { + key[idx] = addr.sin6.sin6_addr.s6_addr[idx]; + } + + if (d_v6Count >= d_maxV6) { + throw std::runtime_error("Table full when trying to block " + addr.toString()); + } + + res = bpf_lookup_elem(d_v6map, &key, &counter); + if (res != -1) { + throw std::runtime_error("Trying to block an already blocked address: " + addr.toString()); + } + + res = bpf_update_elem(d_v6map, key, &counter, 0); + if (res == 0) { + d_v6Count++; + } + } + + if (res != 0) { + throw std::runtime_error("Error adding blocked address " + addr.toString() + ": " + std::string(strerror(errno))); + } +} + +void BPFFilter::unblock(const ComboAddress& addr) +{ + std::unique_lock lock(d_mutex); + + int res = 0; + if (addr.sin4.sin_family == AF_INET) { + uint32_t key = htonl(addr.sin4.sin_addr.s_addr); + res = bpf_delete_elem(d_v4map, &key); + if (res == 0) { + d_v4Count--; + } + } + else if (addr.sin4.sin_family == AF_INET6) { + uint8_t key[16]; + static_assert(sizeof(addr.sin6.sin6_addr.s6_addr) == sizeof(key), "POSIX mandates s6_addr to be an array of 16 uint8_t"); + for (size_t idx = 0; idx < sizeof(key); idx++) { + key[idx] = addr.sin6.sin6_addr.s6_addr[idx]; + } + + res = bpf_delete_elem(d_v6map, key); + if (res == 0) { + d_v6Count--; + } + } + + if (res != 0) { + throw std::runtime_error("Error removing blocked address " + addr.toString() + ": " + std::string(strerror(errno))); + } +} + +void BPFFilter::block(const DNSName& qname, uint16_t qtype) +{ + struct QNameKey key; + struct QNameValue value; + memset(&key, 0, sizeof(key)); + memset(&value, 0, sizeof(value)); + value.counter = 0; + value.qtype = qtype; + + std::string keyStr = qname.toDNSString(); + if (keyStr.size() > sizeof(key.qname)) { + throw std::runtime_error("Invalid QName to block " + qname.toString()); + } + memcpy(key.qname, keyStr.c_str(), keyStr.size()); + + { + std::unique_lock lock(d_mutex); + if (d_qNamesCount >= d_maxQNames) { + throw std::runtime_error("Table full when trying to block " + qname.toString()); + } + + int res = bpf_lookup_elem(d_qnamemap, &key, &value); + if (res != -1) { + throw std::runtime_error("Trying to block an already blocked qname: " + qname.toString()); + } + + res = bpf_update_elem(d_qnamemap, &key, &value, 0); + if (res == 0) { + d_qNamesCount++; + } + + if (res != 0) { + throw std::runtime_error("Error adding blocked qname " + qname.toString() + ": " + std::string(strerror(errno))); + } + } +} + +void BPFFilter::unblock(const DNSName& qname, uint16_t qtype) +{ + struct QNameKey key = { 0 }; + std::string keyStr = qname.toDNSString(); + (void) qtype; + + if (keyStr.size() > sizeof(key.qname)) { + throw std::runtime_error("Invalid QName to block " + qname.toString()); + } + memcpy(key.qname, keyStr.c_str(), keyStr.size()); + + { + std::unique_lock lock(d_mutex); + + int res = bpf_delete_elem(d_qnamemap, &key); + if (res == 0) { + d_qNamesCount--; + } + else { + throw std::runtime_error("Error removing qname address " + qname.toString() + ": " + std::string(strerror(errno))); + } + } +} + +std::vector > BPFFilter::getAddrStats() +{ + std::vector > result; + std::unique_lock lock(d_mutex); + + uint32_t v4Key = 0; + uint32_t nextV4Key; + uint64_t value; + int res = bpf_get_next_key(d_v4map, &v4Key, &nextV4Key); + sockaddr_in v4Addr = { 0 }; + v4Addr.sin_port = 0; + v4Addr.sin_family = AF_INET; + + while (res == 0) { + v4Key = nextV4Key; + if (bpf_lookup_elem(d_v4map, &v4Key, &value) == 0) { + v4Addr.sin_addr.s_addr = ntohl(v4Key); + result.push_back(make_pair(ComboAddress(&v4Addr), value)); + } + + res = bpf_get_next_key(d_v4map, &v4Key, &nextV4Key); + } + + uint8_t v6Key[16]; + uint8_t nextV6Key[16]; + sockaddr_in6 v6Addr = { 0 }; + v6Addr.sin6_family = AF_INET6; + v6Addr.sin6_port = 0; + static_assert(sizeof(v6Addr.sin6_addr.s6_addr) == sizeof(v6Key), "POSIX mandates s6_addr to be an array of 16 uint8_t"); + for (size_t idx = 0; idx < sizeof(v6Key); idx++) { + v6Key[idx] = 0; + } + + res = bpf_get_next_key(d_v6map, &v6Key, &nextV6Key); + + while (res == 0) { + if (bpf_lookup_elem(d_v6map, &nextV6Key, &value) == 0) { + for (size_t idx = 0; idx < sizeof(nextV6Key); idx++) { + v6Addr.sin6_addr.s6_addr[idx] = nextV6Key[idx]; + } + result.push_back(make_pair(ComboAddress(&v6Addr), value)); + } + + res = bpf_get_next_key(d_v6map, &nextV6Key, &nextV6Key); + } + return result; +} + +std::vector > BPFFilter::getQNameStats() +{ + std::vector > result; + std::unique_lock lock(d_mutex); + + struct QNameKey key = {0}; + struct QNameKey nextKey = {0}; + struct QNameValue value; + + int res = bpf_get_next_key(d_qnamemap, &key, &nextKey); + + while (res == 0) { + if (bpf_lookup_elem(d_qnamemap, &nextKey, &value) == 0) { + nextKey.qname[sizeof(nextKey.qname) - 1 ] = '\0'; + result.push_back(std::make_tuple(DNSName((const char*) nextKey.qname, sizeof(nextKey.qname), 0, false), value.qtype, value.counter)); + } + + res = bpf_get_next_key(d_qnamemap, &nextKey, &nextKey); + } + return result; +} +#endif /* HAVE_EBPF */ diff --git a/pdns/bpf-filter.ebpf b/pdns/bpf-filter.ebpf new file mode 100644 index 000000000..0cb10b31d --- /dev/null +++ b/pdns/bpf-filter.ebpf @@ -0,0 +1,3920 @@ +BPF_MOV64_REG(BPF_REG_6,BPF_REG_1), +BPF_MOV64_IMM(BPF_REG_7,2147483647), +BPF_LDX_MEM(BPF_W,BPF_REG_1,BPF_REG_6,16), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_1,ntohs(0x86dd),10), +BPF_JMP_IMM(BPF_JNE,BPF_REG_1,ntohs(0x0800),3916), +BPF_LD_ABS(BPF_W,-2097126), +BPF_STX_MEM(BPF_W,BPF_REG_10,BPF_REG_0,-4), +BPF_LD_MAP_FD(BPF_REG_1,d_v4map), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_10), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_2,-4), +BPF_RAW_INSN(BPF_JMP|BPF_CALL,0,0,0,BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_0,0,43), +BPF_JMP_IMM(BPF_JA,BPF_REG_0,0,3904), +BPF_LD_ABS(BPF_B,-2097130), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-24), +BPF_LD_ABS(BPF_B,-2097129), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-23), +BPF_LD_ABS(BPF_B,-2097128), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-22), +BPF_LD_ABS(BPF_B,-2097127), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-21), +BPF_LD_ABS(BPF_B,-2097126), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-20), +BPF_LD_ABS(BPF_B,-2097125), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-19), +BPF_LD_ABS(BPF_B,-2097124), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-18), +BPF_LD_ABS(BPF_B,-2097123), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-17), +BPF_LD_ABS(BPF_B,-2097122), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-16), +BPF_LD_ABS(BPF_B,-2097121), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-15), +BPF_LD_ABS(BPF_B,-2097120), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-14), +BPF_LD_ABS(BPF_B,-2097119), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-13), +BPF_LD_ABS(BPF_B,-2097118), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-12), +BPF_LD_ABS(BPF_B,-2097117), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-11), +BPF_LD_ABS(BPF_B,-2097116), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-10), +BPF_LD_ABS(BPF_B,-2097115), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-9), +BPF_LD_MAP_FD(BPF_REG_1,d_v6map), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_10), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_2,-24), +BPF_RAW_INSN(BPF_JMP|BPF_CALL,0,0,0,BPF_FUNC_map_lookup_elem), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_0,0,1), +BPF_JMP_IMM(BPF_JA,BPF_REG_0,0,3865), +BPF_MOV64_IMM(BPF_REG_8,-2097078), +BPF_LD_ABS(BPF_B,-2097132), +BPF_JMP_IMM(BPF_JA,BPF_REG_0,0,2), +BPF_MOV64_IMM(BPF_REG_8,-2097098), +BPF_LD_ABS(BPF_B,-2097129), +BPF_ALU64_IMM(BPF_AND,BPF_REG_0,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_0,6,3861), +BPF_MOV64_IMM(BPF_REG_1,0), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_1,-26), +BPF_STX_MEM(BPF_H,BPF_REG_10,BPF_REG_1,-28), +BPF_STX_MEM(BPF_W,BPF_REG_10,BPF_REG_1,-32), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-40), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-48), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-56), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-64), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-72), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-80), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-88), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-96), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-104), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-112), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-120), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-128), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-136), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-144), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-152), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-160), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-168), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-176), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-184), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-192), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-200), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-208), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-216), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-224), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-232), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-240), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-248), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-256), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-264), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-272), +BPF_STX_MEM(BPF_DW,BPF_REG_10,BPF_REG_1,-280), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_IMM(BPF_REG_9,1), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_8), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3803), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-280), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_OR,BPF_REG_7,1), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_JMP_IMM(BPF_JNE,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,2), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3790), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-279), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,2), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,3), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3777), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-278), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,3), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,4), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3764), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-277), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,4), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,5), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3749), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-276), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,5), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,6), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3734), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-275), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,6), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,7), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3719), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-274), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,7), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,8), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3704), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-273), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,8), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3689), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-272), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,9), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,10), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3674), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-271), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,10), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,11), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3659), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-270), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,11), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,12), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3644), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-269), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,12), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,13), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3629), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-268), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,13), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,14), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3614), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-267), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,14), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,15), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3599), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-266), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,15), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,16), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3584), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-265), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,16), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,17), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3569), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-264), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,17), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,18), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3554), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-263), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,18), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,19), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3539), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-262), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,19), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,20), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3524), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-261), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,20), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,21), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3509), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-260), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,21), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,22), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3494), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-259), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,22), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,23), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3479), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-258), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,23), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,24), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3464), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-257), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,24), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,25), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3449), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-256), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,25), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,26), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3434), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-255), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,26), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,27), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3419), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-254), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,27), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,28), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3404), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-253), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,28), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,29), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3389), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-252), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,29), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,30), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3374), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-251), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,30), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,31), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3359), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-250), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,31), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,32), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3344), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-249), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,32), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,33), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3329), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-248), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,33), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,34), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3314), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-247), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,34), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,35), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3299), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-246), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,35), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,36), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3284), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-245), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,36), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,37), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3269), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-244), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,37), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,38), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3254), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-243), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,38), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,39), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3239), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-242), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,39), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,40), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3224), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-241), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,40), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,41), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3209), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-240), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,41), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,42), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3194), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-239), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,42), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,43), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3179), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-238), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,43), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,44), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3164), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-237), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,44), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,45), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3149), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-236), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,45), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,46), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3134), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-235), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,46), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,47), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3119), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-234), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,47), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,48), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3104), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-233), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,48), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,49), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3089), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-232), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,49), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,50), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3074), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-231), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,50), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,51), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3059), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-230), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,51), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,52), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3044), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-229), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,52), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,53), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,3029), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-228), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,53), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,54), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,3014), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-227), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,54), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,55), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2999), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-226), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,55), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,56), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2984), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-225), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,56), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,57), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2969), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-224), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,57), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,58), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2954), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-223), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,58), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,59), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2939), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-222), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,59), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,60), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2924), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-221), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,60), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,61), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2909), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-220), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,61), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,62), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2894), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-219), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,62), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,63), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2879), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-218), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,63), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,64), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2864), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-217), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,64), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,65), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2849), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-216), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,65), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,66), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2834), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-215), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,66), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,67), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2819), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-214), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,67), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,68), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2804), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-213), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,68), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,69), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2789), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-212), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,69), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,70), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2774), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-211), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,70), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,71), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2759), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-210), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,71), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,72), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2744), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-209), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,72), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,73), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2729), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-208), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,73), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,74), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2714), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-207), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,74), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,75), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2699), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-206), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,75), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,76), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2684), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-205), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,76), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,77), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2669), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-204), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,77), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,78), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2654), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-203), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,78), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,79), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2639), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-202), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,79), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,80), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2624), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-201), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,80), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,81), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2609), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-200), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,81), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,82), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2594), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-199), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,82), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,83), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2579), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-198), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,83), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,84), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2564), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-197), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,84), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,85), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2549), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-196), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,85), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,86), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2534), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-195), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,86), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,87), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2519), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-194), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,87), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,88), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2504), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-193), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,88), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,89), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2489), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-192), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,89), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,90), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2474), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-191), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,90), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,91), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2459), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-190), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,91), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,92), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2444), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-189), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,92), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,93), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2429), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-188), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,93), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,94), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2414), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-187), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,94), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,95), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2399), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-186), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,95), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,96), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2384), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-185), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,96), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,97), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2369), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-184), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,97), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,98), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2354), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-183), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,98), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,99), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2339), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-182), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,99), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,100), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2324), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-181), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,100), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,101), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2309), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-180), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,101), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,102), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2294), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-179), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,102), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,103), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2279), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-178), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,103), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,104), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2264), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-177), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,104), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,105), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2249), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-176), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,105), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,106), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2234), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-175), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,106), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,107), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2219), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-174), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,107), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,108), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2204), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-173), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,108), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,109), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2189), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-172), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,109), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,110), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2174), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-171), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,110), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,111), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2159), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-170), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,111), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,112), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2144), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-169), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,112), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,113), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2129), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-168), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,113), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,114), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2114), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-167), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,114), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,115), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2099), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-166), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,115), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,116), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2084), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-165), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,116), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,117), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2069), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-164), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,117), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,118), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2054), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-163), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,118), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,119), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2039), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-162), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,119), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,120), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,2024), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-161), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,120), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,121), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,2009), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-160), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,121), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,122), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1994), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-159), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,122), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,123), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1979), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-158), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,123), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,124), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1964), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-157), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,124), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,125), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1949), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-156), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,125), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,126), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1934), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-155), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,126), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,127), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1919), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-154), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,127), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,128), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1904), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-153), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_OR,BPF_REG_8,128), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,129), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1889), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-152), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_OR,BPF_REG_7,129), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,130), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1874), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-151), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,130), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,131), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1859), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-150), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,131), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,132), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1844), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-149), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,132), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,133), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1829), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-148), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,133), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,134), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1814), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-147), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,134), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,135), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1799), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-146), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,135), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,136), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1784), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-145), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,136), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,137), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1769), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-144), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,137), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,138), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1754), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-143), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,138), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,139), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1739), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-142), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,139), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,140), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1724), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-141), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,140), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,141), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1709), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-140), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,141), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,142), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1694), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-139), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,142), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,143), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1679), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-138), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,143), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,144), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1664), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-137), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,144), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,145), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1649), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-136), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,145), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,146), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1634), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-135), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,146), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,147), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1619), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-134), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,147), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,148), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1604), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-133), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,148), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,149), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1589), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-132), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,149), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,150), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1574), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-131), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,150), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,151), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1559), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-130), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,151), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,152), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1544), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-129), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,152), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,153), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1529), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-128), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,153), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,154), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1514), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-127), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,154), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,155), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1499), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-126), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,155), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,156), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1484), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-125), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,156), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,157), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1469), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-124), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,157), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,158), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1454), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-123), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,158), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,159), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1439), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-122), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,159), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,160), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1424), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-121), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,160), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,161), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1409), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-120), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,161), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,162), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1394), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-119), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,162), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,163), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1379), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-118), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,163), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,164), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1364), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-117), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,164), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,165), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1349), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-116), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,165), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,166), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1334), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-115), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,166), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,167), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1319), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-114), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,167), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,168), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1304), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-113), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,168), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,169), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1289), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-112), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,169), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,170), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1274), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-111), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,170), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,171), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1259), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-110), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,171), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,172), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1244), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-109), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,172), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,173), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1229), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-108), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,173), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,174), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1214), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-107), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,174), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,175), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1199), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-106), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,175), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,176), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1184), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-105), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,176), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,177), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1169), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-104), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,177), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,178), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1154), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-103), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,178), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,179), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1139), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-102), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,179), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,180), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1124), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-101), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,180), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,181), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1109), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-100), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,181), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,182), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1094), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-99), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,182), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,183), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1079), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-98), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,183), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,184), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1064), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-97), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,184), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,185), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1049), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-96), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,185), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,186), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1034), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-95), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,186), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,187), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,1019), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-94), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,187), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,188), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,1004), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-93), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,188), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,189), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,989), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-92), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,189), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,190), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,974), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-91), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,190), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,191), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,959), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-90), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,191), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,192), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,944), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-89), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,192), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,193), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,929), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-88), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,193), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,194), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,914), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-87), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,194), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,195), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,899), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-86), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,195), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,196), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,884), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-85), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,196), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,197), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,869), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-84), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,197), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,198), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,854), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-83), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,198), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,199), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,839), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-82), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,199), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,200), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,824), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-81), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,200), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,201), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,809), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-80), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,201), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,202), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,794), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-79), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,202), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,203), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,779), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-78), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,203), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,204), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,764), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-77), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,204), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,205), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,749), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-76), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,205), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,206), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,734), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-75), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,206), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,207), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,719), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-74), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,207), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,208), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,704), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-73), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,208), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,209), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,689), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-72), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,209), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,210), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,674), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-71), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,210), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,211), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,659), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-70), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,211), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,212), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,644), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-69), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,212), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,213), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,629), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-68), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,213), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,214), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,614), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-67), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,214), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,215), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,599), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-66), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,215), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,216), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,584), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-65), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,216), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,217), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,569), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-64), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,217), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,218), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,554), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-63), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,218), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,219), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,539), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-62), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,219), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,220), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,524), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-61), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,220), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,221), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,509), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-60), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,221), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,222), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,494), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-59), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,222), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,223), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,479), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-58), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,223), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,224), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,464), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-57), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,224), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,225), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,449), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-56), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,225), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,226), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,434), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-55), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,226), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,227), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,419), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-54), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,227), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,228), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,404), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-53), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,228), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,229), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,389), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-52), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,229), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,230), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,374), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-51), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,230), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,231), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,359), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-50), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,231), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,232), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,344), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-49), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,232), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,233), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,329), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-48), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,233), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,234), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,314), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-47), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,234), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,235), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,299), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-46), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,235), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,236), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,284), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-45), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,236), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,237), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,269), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-44), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,237), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,238), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,254), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-43), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,238), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,239), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,239), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-42), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,239), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,240), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,224), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-41), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,240), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,241), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,209), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-40), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,241), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,242), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,194), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-39), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,242), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,243), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,179), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-38), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,243), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,244), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,164), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-37), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,244), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,245), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,149), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-36), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,245), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,246), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,134), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-35), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,246), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,247), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,119), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-34), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,247), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,248), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,104), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-33), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,248), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,249), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,89), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-32), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,249), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,250), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,74), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-31), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,250), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,251), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,59), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-30), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,251), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,252), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,44), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-29), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,252), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_7), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,4), +BPF_MOV64_IMM(BPF_REG_9,253), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_8,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_8,0,29), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-28), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,253), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_7,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_8), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_7,-1), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_8,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_8,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_8,0,4), +BPF_MOV64_IMM(BPF_REG_9,254), +BPF_MOV64_REG(BPF_REG_7,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_7,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_7,0,14), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-27), +BPF_MOV64_REG(BPF_REG_8,BPF_REG_2), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_8,254), +BPF_MOV64_REG(BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_B,BPF_REG_0,BPF_REG_8,0,0), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_9), +BPF_MOV64_IMM(BPF_REG_9,255), +BPF_ALU64_IMM(BPF_LSH,BPF_REG_7,32), +BPF_ALU64_IMM(BPF_ARSH,BPF_REG_7,32), +BPF_JMP_IMM(BPF_JSGT,BPF_REG_7,0,3), +BPF_MOV64_REG(BPF_REG_1,BPF_REG_0), +BPF_ALU64_IMM(BPF_AND,BPF_REG_1,255), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_1,0,1), +BPF_STX_MEM(BPF_B,BPF_REG_10,BPF_REG_0,-26), +BPF_ALU64_REG(BPF_ADD,BPF_REG_9,BPF_REG_2), +BPF_RAW_INSN(BPF_LD|BPF_IND|BPF_H,BPF_REG_0,BPF_REG_9,0,0), +BPF_MOV64_REG(BPF_REG_6,BPF_REG_0), +BPF_LD_MAP_FD(BPF_REG_1,d_qnamemap), +BPF_MOV64_REG(BPF_REG_2,BPF_REG_10), +BPF_ALU64_IMM(BPF_ADD,BPF_REG_2,-280), +BPF_RAW_INSN(BPF_JMP|BPF_CALL,0,0,0,BPF_FUNC_map_lookup_elem), +BPF_MOV64_IMM(BPF_REG_7,2147483647), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_0,0,7), +BPF_LDX_MEM(BPF_H,BPF_REG_1,BPF_REG_0,8), +BPF_JMP_IMM(BPF_JEQ,BPF_REG_1,255,2), +BPF_ALU64_IMM(BPF_AND,BPF_REG_6,65535), +BPF_JMP_REG(BPF_JNE,BPF_REG_6,BPF_REG_1,3), +BPF_MOV64_IMM(BPF_REG_1,1), +BPF_RAW_INSN(BPF_STX|BPF_XADD|BPF_DW,BPF_REG_0,BPF_REG_1,0,0), +BPF_MOV64_IMM(BPF_REG_7,0), +BPF_MOV64_REG(BPF_REG_0,BPF_REG_7), +BPF_EXIT_INSN(), diff --git a/pdns/bpf-filter.ebpf.src b/pdns/bpf-filter.ebpf.src new file mode 100644 index 000000000..eaaf492bc --- /dev/null +++ b/pdns/bpf-filter.ebpf.src @@ -0,0 +1,457 @@ + +#include +#include +#include +#include +#include +#include +#include + +struct dnsheader { + unsigned id :16; /* query identification number */ +#if BYTE_ORDER == BIG_ENDIAN + /* fields in third byte */ + unsigned qr: 1; /* response flag */ + unsigned opcode: 4; /* purpose of message */ + unsigned aa: 1; /* authoritative answer */ + unsigned tc: 1; /* truncated message */ + unsigned rd: 1; /* recursion desired */ + /* fields in fourth byte */ + unsigned ra: 1; /* recursion available */ + unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */ + unsigned ad: 1; /* authentic data from named */ + unsigned cd: 1; /* checking disabled by resolver */ + unsigned rcode :4; /* response code */ +#elif BYTE_ORDER == LITTLE_ENDIAN || BYTE_ORDER == PDP_ENDIAN + /* fields in third byte */ + unsigned rd :1; /* recursion desired */ + unsigned tc :1; /* truncated message */ + unsigned aa :1; /* authoritative answer */ + unsigned opcode :4; /* purpose of message */ + unsigned qr :1; /* response flag */ + /* fields in fourth byte */ + unsigned rcode :4; /* response code */ + unsigned cd: 1; /* checking disabled by resolver */ + unsigned ad: 1; /* authentic data from named */ + unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */ + unsigned ra :1; /* recursion available */ +#endif + /* remaining bytes */ + unsigned qdcount :16; /* number of question entries */ + unsigned ancount :16; /* number of answer entries */ + unsigned nscount :16; /* number of authority entries */ + unsigned arcount :16; /* number of resource entries */ +}; + +struct QNameKey +{ + uint8_t qname[255]; +}; + +struct KeyV6 +{ + uint8_t src[16]; +}; + +struct QNameValue +{ + u64 counter; + u16 qtype; +}; + +#define IP_MF 0x2000 +#define IP_OFFSET 0x1FFF + +BPF_TABLE("hash", u32, u64, v4filter, 1024); +BPF_TABLE("hash", struct KeyV6, u64, v6filter, 1024); +BPF_TABLE("hash", struct QNameKey, struct QNameValue, qnamefilter, 1024); + +int bpf_dns_filter(struct __sk_buff *skb) { + u8 ip_proto; + u32 proto_off; + int nh_off = BPF_LL_OFF + ETH_HLEN; + + if (skb->protocol == ntohs(0x0800)) { + u32 key; + int off = nh_off + offsetof(struct iphdr, saddr); + key = load_word(skb, off); + + u64* counter = v4filter.lookup(&key); + if (counter) { + __sync_fetch_and_add(counter, 1); + return 0; + } + +#if 0 + if (load_half(skb, (nh_off + (int32_t)offsetof(struct iphdr, frag_off)) & (IP_MF | IP_OFFSET))) { + /* fragment */ + return 2147483647; + } +#endif + ip_proto = load_byte(skb, nh_off + offsetof(struct iphdr, protocol)); + proto_off = nh_off + sizeof(struct iphdr); + } + else if (skb->protocol == ntohs(0x86DD)) { + struct KeyV6 key; + int off = nh_off + offsetof(struct ipv6hdr, saddr); + key.src[0] = load_byte(skb, off++); + key.src[1] = load_byte(skb, off++); + key.src[2] = load_byte(skb, off++); + key.src[3] = load_byte(skb, off++); + key.src[4] = load_byte(skb, off++); + key.src[5] = load_byte(skb, off++); + key.src[6] = load_byte(skb, off++); + key.src[7] = load_byte(skb, off++); + key.src[8] = load_byte(skb, off++); + key.src[9] = load_byte(skb, off++); + key.src[10] = load_byte(skb, off++); + key.src[11] = load_byte(skb, off++); + key.src[12] = load_byte(skb, off++); + key.src[13] = load_byte(skb, off++); + key.src[14] = load_byte(skb, off++); + key.src[15] = load_byte(skb, off++); + + u64* counter = v6filter.lookup(&key); + if (counter) { + __sync_fetch_and_add(counter, 1); + return 0; + } + + ip_proto = load_byte(skb, nh_off + offsetof(struct ipv6hdr, nexthdr)); + proto_off = nh_off + sizeof(struct ipv6hdr); + } + else { + /* neither IPv4 not IPv6, well */ + return 2147483647; + } + + /* allow TCP */ + if (ip_proto == IPPROTO_TCP) { + return 2147483647; + } + + int dns_off = proto_off + sizeof(struct udphdr); + int qname_off = dns_off + sizeof(struct dnsheader); + size_t idx = 0; + struct QNameKey qkey = { 0 }; + int32_t labellen = 0; + uint8_t temp; + +#define FILL_ONE_KEY \ + temp = load_byte(skb, qname_off + idx); \ + labellen--; \ + if (labellen < 0) { \ + labellen = temp; \ + if (labellen == 0) { \ + goto end; \ + } \ + } \ + qkey.qname[idx] = temp; \ + idx++; + + /* 0 - 50 */ + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + /* 50 - 100 */ + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + /* 100 - 150 */ + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + /* 150 - 200 */ + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + /* 200 - 250 */ + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + /* 250 - 255 */ + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + FILL_ONE_KEY + + end: + + { + if (idx < 255) { + idx++; + } + u16 qtype = load_half(skb, (qname_off + idx)); + idx += 2; + + struct QNameValue* qvalue = qnamefilter.lookup(&qkey); + if (qvalue && + (qvalue->qtype == 255 || qtype == qvalue->qtype)) { + __sync_fetch_and_add(&qvalue->counter, 1); + return 0; + } + } + + return 2147483647; +} diff --git a/pdns/bpf-filter.hh b/pdns/bpf-filter.hh new file mode 100644 index 000000000..a7dda45f1 --- /dev/null +++ b/pdns/bpf-filter.hh @@ -0,0 +1,36 @@ +#pragma once +#include "config.h" + +#include + +#include "iputils.hh" + +#ifdef HAVE_EBPF + +class BPFFilter +{ +public: + BPFFilter(uint32_t maxV4Addresses, uint32_t maxV6Addresses, uint32_t maxQNames); + ~BPFFilter(); + void addSocket(int sock); + void block(const ComboAddress& addr); + void block(const DNSName& qname, uint16_t qtype=255); + void unblock(const ComboAddress& addr); + void unblock(const DNSName& qname, uint16_t qtype=255); + std::vector > getAddrStats(); + std::vector > getQNameStats(); +private: + std::mutex d_mutex; + uint32_t d_maxV4; + uint32_t d_maxV6; + uint32_t d_maxQNames; + uint32_t d_v4Count{0}; + uint32_t d_v6Count{0}; + uint32_t d_qNamesCount{0}; + int d_v4map{-1}; + int d_v6map{-1}; + int d_qnamemap{-1}; + int d_filter{-1}; +}; + +#endif /* HAVE_EBPF */ diff --git a/pdns/dnsdist-dynbpf.cc b/pdns/dnsdist-dynbpf.cc new file mode 100644 index 000000000..a8bd68a2d --- /dev/null +++ b/pdns/dnsdist-dynbpf.cc @@ -0,0 +1,40 @@ +#include "dnsdist-dynbpf.hh" + +#ifdef HAVE_EBPF + +void DynBPFFilter::block(const ComboAddress& addr, const struct timespec& until) +{ + std::unique_lock lock(d_mutex); + + const container_t::iterator it = d_entries.find(addr); + if (it != d_entries.end()) { + if (it->d_until < until) { + d_entries.replace(it, BlockEntry(addr, until)); + } + } + else { + d_bpf->block(addr); + d_entries.insert(BlockEntry(addr, until)); + } +} + +void DynBPFFilter::purgeExpired(const struct timespec& now) +{ + std::unique_lock lock(d_mutex); + + typedef nth_index::type ordered_until; + ordered_until& ou = get<1>(d_entries); + + for (ordered_until::iterator it=ou.begin(); it != ou.end(); ) { + if (it->d_until < now) { + ComboAddress addr = it->d_addr; + it = ou.erase(it); + d_bpf->unblock(addr); + } + else { + break; + } + } +} + +#endif /* HAVE_EBPF */ diff --git a/pdns/dnsdist-dynbpf.hh b/pdns/dnsdist-dynbpf.hh new file mode 100644 index 000000000..ebd987611 --- /dev/null +++ b/pdns/dnsdist-dynbpf.hh @@ -0,0 +1,45 @@ +#pragma once +#include "config.h" + +#include + +#include "bpf-filter.hh" +#include "iputils.hh" + +#ifdef HAVE_EBPF + +#include +#include + +class DynBPFFilter +{ +public: + DynBPFFilter(std::shared_ptr bpf): d_bpf(bpf) + { + } + ~DynBPFFilter() + { + } + void block(const ComboAddress& addr, const struct timespec& until); + void purgeExpired(const struct timespec& now); +private: + struct BlockEntry + { + BlockEntry(const ComboAddress& addr, const struct timespec until): d_addr(addr), d_until(until) + { + } + ComboAddress d_addr; + struct timespec d_until; + }; + typedef multi_index_container, ComboAddress::addressOnlyLessThan >, + ordered_non_unique< member > + > + > container_t; + container_t d_entries; + std::mutex d_mutex; + std::shared_ptr d_bpf; +}; + +#endif /* HAVE_EBPF */ diff --git a/pdns/dnsdist-lua2.cc b/pdns/dnsdist-lua2.cc index 17be04bac..40c24ddd8 100644 --- a/pdns/dnsdist-lua2.cc +++ b/pdns/dnsdist-lua2.cc @@ -660,4 +660,142 @@ void moreLua(bool client) g_resprulactions.setState(rules); }); + g_lua.writeFunction("showBinds", []() { + setLuaNoSideEffect(); + try { + ostringstream ret; + boost::format fmt("%1$-3d %2$-20.20s %|25t|%3$-8.8s %|35t|%4%" ); + // 1 2 3 4 + ret << (fmt % "#" % "Address" % "Protocol" % "Queries" ) << endl; + + size_t counter = 0; + for (const auto& front : g_frontends) { + ret << (fmt % counter % front->local.toStringWithPort() % (front->udpFD != -1 ? "UDP" : "TCP") % front->queries) << endl; + counter++; + } + g_outputBuffer=ret.str(); + }catch(std::exception& e) { g_outputBuffer=e.what(); throw; } + }); + + g_lua.writeFunction("getBind", [](size_t num) { + setLuaNoSideEffect(); + ClientState* ret = nullptr; + if(num < g_frontends.size()) { + ret=g_frontends[num]; + } + return ret; + }); + + g_lua.registerFunction("toString", [](const ClientState& fe) { + setLuaNoSideEffect(); + return fe.local.toStringWithPort(); + }); + +#ifdef HAVE_EBPF + g_lua.writeFunction("newBPFFilter", [](uint32_t maxV4, uint32_t maxV6, uint32_t maxQNames) { + return std::make_shared(maxV4, maxV6, maxQNames); + }); + + g_lua.registerFunction::*)(const ComboAddress& ca)>("block", [](std::shared_ptr bpf, const ComboAddress& ca) { + if (bpf) { + return bpf->block(ca); + } + }); + + g_lua.registerFunction::*)(const DNSName& qname, boost::optional qtype)>("blockQName", [](std::shared_ptr bpf, const DNSName& qname, boost::optional qtype) { + if (bpf) { + return bpf->block(qname, qtype ? *qtype : 255); + } + }); + + g_lua.registerFunction::*)(const ComboAddress& ca)>("unblock", [](std::shared_ptr bpf, const ComboAddress& ca) { + if (bpf) { + return bpf->unblock(ca); + } + }); + + g_lua.registerFunction::*)(const DNSName& qname, boost::optional qtype)>("unblockQName", [](std::shared_ptr bpf, const DNSName& qname, boost::optional qtype) { + if (bpf) { + return bpf->unblock(qname, qtype ? *qtype : 255); + } + }); + + g_lua.registerFunction::*)()>("getStats", [](const std::shared_ptr bpf) { + setLuaNoSideEffect(); + std::string res; + if (bpf) { + std::vector > stats = bpf->getAddrStats(); + for (const auto& value : stats) { + if (value.first.sin4.sin_family == AF_INET) { + res += value.first.toString() + ": " + std::to_string(value.second) + "\n"; + } + else if (value.first.sin4.sin_family == AF_INET6) { + res += "[" + value.first.toString() + "]: " + std::to_string(value.second) + "\n"; + } + } + std::vector > qstats = bpf->getQNameStats(); + for (const auto& value : qstats) { + res += std::get<0>(value).toString() + " " + std::to_string(std::get<1>(value)) + ": " + std::to_string(std::get<2>(value)) + "\n"; + } + } + return res; + }); + + g_lua.registerFunction::*)()>("attachToAllBinds", [](std::shared_ptr bpf) { + std::string res; + if (bpf) { + for (const auto& front : g_frontends) { + bpf->addSocket(front->udpFD != -1 ? front->udpFD : front->tcpFD); + } + } + }); + + g_lua.registerFunction)>("attachFilter", [](ClientState& frontend, std::shared_ptr bpf) { + if (bpf) { + bpf->addSocket(frontend.udpFD != -1 ? frontend.udpFD : frontend.tcpFD); + } + }); + + g_lua.writeFunction("setDefaultBPFFilter", [](std::shared_ptr bpf) { + if (g_configurationDone) { + g_outputBuffer="setDefaultBPFFilter() cannot be used at runtime!\n"; + return; + } + g_defaultBPFFilter = bpf; + }); + + g_lua.writeFunction("newDynBPFFilter", [](std::shared_ptr bpf) { + return std::make_shared(bpf); + }); + + g_lua.registerFunction::*)(const ComboAddress& addr, boost::optional seconds)>("block", [](std::shared_ptr dbpf, const ComboAddress& addr, boost::optional seconds) { + if (dbpf) { + struct timespec until; + clock_gettime(CLOCK_MONOTONIC, &until); + until.tv_sec += seconds ? *seconds : 10; + dbpf->block(addr, until); + } + }); + + g_lua.registerFunction::*)()>("purgeExpired", [](std::shared_ptr dbpf) { + if (dbpf) { + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + dbpf->purgeExpired(now); + } + }); + + g_lua.writeFunction("addBPFFilterDynBlocks", [](const map& m, std::shared_ptr dynbpf, boost::optional seconds) { + setLuaSideEffect(); + struct timespec until, now; + clock_gettime(CLOCK_MONOTONIC, &now); + until=now; + int actualSeconds = seconds ? *seconds : 10; + until.tv_sec += actualSeconds; + for(const auto& capair : m) { + dynbpf->block(capair.first, until); + } + }); + +#endif /* HAVE_EBPF */ } diff --git a/pdns/dnsdist.cc b/pdns/dnsdist.cc index a496e2b6e..998b59859 100644 --- a/pdns/dnsdist.cc +++ b/pdns/dnsdist.cc @@ -77,6 +77,9 @@ vector> g_locals; #ifdef HAVE_DNSCRYPT std::vector> g_dnsCryptLocals; #endif +#ifdef HAVE_EBPF +shared_ptr g_defaultBPFFilter; +#endif /* HAVE_EBPF */ vector g_frontends; GlobalStateHolder g_pools; @@ -1639,6 +1642,13 @@ try } #endif +#ifdef HAVE_EBPF + if (g_defaultBPFFilter) { + g_defaultBPFFilter->addSocket(cs->udpFD); + vinfolog("Attaching default BPF Filter to UDP frontend %s", cs->local.toStringWithPort()); + } +#endif /* HAVE_EBPF */ + SBind(cs->udpFD, cs->local); toLaunch.push_back(cs); g_frontends.push_back(cs); @@ -1667,6 +1677,13 @@ try SSetsockopt(cs->tcpFD, SOL_SOCKET, SO_REUSEPORT, 1); } #endif +#ifdef HAVE_EBPF + if (g_defaultBPFFilter) { + g_defaultBPFFilter->addSocket(cs->tcpFD); + vinfolog("Attaching default BPF Filter to TCP frontend %s", cs->local.toStringWithPort()); + } +#endif /* HAVE_EBPF */ + // if(g_vm.count("bind-non-local")) bindAny(cs->local.sin4.sin_family, cs->tcpFD); SBind(cs->tcpFD, cs->local); @@ -1695,6 +1712,12 @@ try setsockopt(cs->udpFD, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one)); #endif } +#ifdef HAVE_EBPF + if (g_defaultBPFFilter) { + g_defaultBPFFilter->addSocket(cs->udpFD); + vinfolog("Attaching default BPF Filter to UDP DNSCrypt frontend %s", cs->local.toStringWithPort()); + } +#endif /* HAVE_EBPF */ SBind(cs->udpFD, cs->local); toLaunch.push_back(cs); g_frontends.push_back(cs); @@ -1716,6 +1739,12 @@ try if(cs->local.sin4.sin_family == AF_INET6) { SSetsockopt(cs->tcpFD, IPPROTO_IPV6, IPV6_V6ONLY, 1); } +#ifdef HAVE_EBPF + if (g_defaultBPFFilter) { + g_defaultBPFFilter->addSocket(cs->tcpFD); + vinfolog("Attaching default BPF Filter to TCP DNSCrypt frontend %s", cs->local.toStringWithPort()); + } +#endif /* HAVE_EBPF */ bindAny(cs->local.sin4.sin_family, cs->tcpFD); SBind(cs->tcpFD, cs->local); SListen(cs->tcpFD, 64); diff --git a/pdns/dnsdist.hh b/pdns/dnsdist.hh index 5b14ca955..c30d7e318 100644 --- a/pdns/dnsdist.hh +++ b/pdns/dnsdist.hh @@ -14,6 +14,8 @@ #include "dnscrypt.hh" #include "dnsdist-cache.hh" #include "gettime.hh" +#include "dnsdist-dynbpf.hh" +#include "bpf-filter.hh" #ifdef HAVE_PROTOBUF #include @@ -496,6 +498,10 @@ extern bool g_ECSOverride; extern bool g_verboseHealthChecks; extern uint32_t g_staleCacheEntriesTTL; +#ifdef HAVE_EBPF +extern shared_ptr g_defaultBPFFilter; +#endif /* HAVE_EBPF */ + struct dnsheader; void controlThread(int fd, ComboAddress local); diff --git a/pdns/dnsdistdist/Makefile.am b/pdns/dnsdistdist/Makefile.am index 0f6943ec6..ae8c0bfe0 100644 --- a/pdns/dnsdistdist/Makefile.am +++ b/pdns/dnsdistdist/Makefile.am @@ -42,6 +42,7 @@ EXTRA_DIST=dnslabeltext.rl \ src_js \ dnsdist.service.in \ lua_hpp.mk + bpf-filter.ebpf bpf-filter.ebpf.src bin_PROGRAMS = dnsdist @@ -59,9 +60,11 @@ dnsdist-web.$(OBJEXT): htmlfiles.h dnsdist_SOURCES = \ base64.hh \ + bpf-filter.cc bpf-filter.hh \ dns.cc dns.hh \ dnscrypt.cc dnscrypt.hh \ dnsdist.cc dnsdist.hh \ + dnsdist-dynbpf.cc dnsdist-dynbpf.hh \ dnsdist-cache.cc dnsdist-cache.hh \ dnsdist-carbon.cc \ dnsdist-console.cc \ @@ -97,7 +100,8 @@ dnsdist_SOURCES = \ ext/luawrapper/include/LuaContext.hpp \ ext/json11/json11.cpp \ ext/json11/json11.hpp \ - ext/incbin/incbin.h + ext/incbin/incbin.h \ + ext/libbpf/libbpf.h dnsdist_LDFLAGS = \ $(AM_LDFLAGS) \ diff --git a/pdns/dnsdistdist/bpf-filter.cc b/pdns/dnsdistdist/bpf-filter.cc new file mode 120000 index 000000000..c221c9206 --- /dev/null +++ b/pdns/dnsdistdist/bpf-filter.cc @@ -0,0 +1 @@ +../bpf-filter.cc \ No newline at end of file diff --git a/pdns/dnsdistdist/bpf-filter.ebpf b/pdns/dnsdistdist/bpf-filter.ebpf new file mode 120000 index 000000000..669e0425c --- /dev/null +++ b/pdns/dnsdistdist/bpf-filter.ebpf @@ -0,0 +1 @@ +../bpf-filter.ebpf \ No newline at end of file diff --git a/pdns/dnsdistdist/bpf-filter.ebpf.src b/pdns/dnsdistdist/bpf-filter.ebpf.src new file mode 120000 index 000000000..e3c87ff0e --- /dev/null +++ b/pdns/dnsdistdist/bpf-filter.ebpf.src @@ -0,0 +1 @@ +../bpf-filter.ebpf.src \ No newline at end of file diff --git a/pdns/dnsdistdist/bpf-filter.hh b/pdns/dnsdistdist/bpf-filter.hh new file mode 120000 index 000000000..e98b996ed --- /dev/null +++ b/pdns/dnsdistdist/bpf-filter.hh @@ -0,0 +1 @@ +../bpf-filter.hh \ No newline at end of file diff --git a/pdns/dnsdistdist/configure.ac b/pdns/dnsdistdist/configure.ac index cded42e42..d7661fc7c 100644 --- a/pdns/dnsdistdist/configure.ac +++ b/pdns/dnsdistdist/configure.ac @@ -34,6 +34,7 @@ BOOST_FOREACH PDNS_ENABLE_UNIT_TESTS PDNS_CHECK_RE2 DNSDIST_ENABLE_DNSCRYPT +PDNS_WITH_EBPF AX_AVAILABLE_SYSTEMD AM_CONDITIONAL([HAVE_SYSTEMD], [ test x"$systemd" = "xy" ]) diff --git a/pdns/dnsdistdist/dnsdist-dynbpf.cc b/pdns/dnsdistdist/dnsdist-dynbpf.cc new file mode 120000 index 000000000..6463b56fc --- /dev/null +++ b/pdns/dnsdistdist/dnsdist-dynbpf.cc @@ -0,0 +1 @@ +../dnsdist-dynbpf.cc \ No newline at end of file diff --git a/pdns/dnsdistdist/dnsdist-dynbpf.hh b/pdns/dnsdistdist/dnsdist-dynbpf.hh new file mode 120000 index 000000000..9ac055ffc --- /dev/null +++ b/pdns/dnsdistdist/dnsdist-dynbpf.hh @@ -0,0 +1 @@ +../dnsdist-dynbpf.hh \ No newline at end of file diff --git a/pdns/dnsdistdist/ext/libbpf/libbpf.h b/pdns/dnsdistdist/ext/libbpf/libbpf.h new file mode 120000 index 000000000..828c70ffb --- /dev/null +++ b/pdns/dnsdistdist/ext/libbpf/libbpf.h @@ -0,0 +1 @@ +../../../../ext/libbpf/libbpf.h \ No newline at end of file diff --git a/pdns/dnsdistdist/m4/pdns_with_ebpf.m4 b/pdns/dnsdistdist/m4/pdns_with_ebpf.m4 new file mode 120000 index 000000000..b090a865a --- /dev/null +++ b/pdns/dnsdistdist/m4/pdns_with_ebpf.m4 @@ -0,0 +1 @@ +../../../m4/pdns_with_ebpf.m4 \ No newline at end of file