/* Generated by ./gen_bpf_attr_check.sh from bpf_attr.h; do not edit. */
#include "defs.h"
#ifdef HAVE_LINUX_BPF_H
# include <linux/bpf.h>
# include "bpf_attr.h"
# include "static_assert.h"


# ifdef HAVE_UNION_BPF_ATTR_MAP_TYPE
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_type) == sizeof_field(union bpf_attr, map_type),
		      "BPF_MAP_CREATE_struct.map_type size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_type) == offsetof(union bpf_attr, map_type),
		      "BPF_MAP_CREATE_struct.map_type offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_TYPE */

# ifdef HAVE_UNION_BPF_ATTR_KEY_SIZE
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, key_size) == sizeof_field(union bpf_attr, key_size),
		      "BPF_MAP_CREATE_struct.key_size size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, key_size) == offsetof(union bpf_attr, key_size),
		      "BPF_MAP_CREATE_struct.key_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_KEY_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_VALUE_SIZE
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, value_size) == sizeof_field(union bpf_attr, value_size),
		      "BPF_MAP_CREATE_struct.value_size size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, value_size) == offsetof(union bpf_attr, value_size),
		      "BPF_MAP_CREATE_struct.value_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_VALUE_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_MAX_ENTRIES
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, max_entries) == sizeof_field(union bpf_attr, max_entries),
		      "BPF_MAP_CREATE_struct.max_entries size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, max_entries) == offsetof(union bpf_attr, max_entries),
		      "BPF_MAP_CREATE_struct.max_entries offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAX_ENTRIES */

# ifdef HAVE_UNION_BPF_ATTR_MAP_FLAGS
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_flags) == sizeof_field(union bpf_attr, map_flags),
		      "BPF_MAP_CREATE_struct.map_flags size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_flags) == offsetof(union bpf_attr, map_flags),
		      "BPF_MAP_CREATE_struct.map_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_INNER_MAP_FD
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, inner_map_fd) == sizeof_field(union bpf_attr, inner_map_fd),
		      "BPF_MAP_CREATE_struct.inner_map_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, inner_map_fd) == offsetof(union bpf_attr, inner_map_fd),
		      "BPF_MAP_CREATE_struct.inner_map_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_INNER_MAP_FD */

# ifdef HAVE_UNION_BPF_ATTR_NUMA_NODE
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, numa_node) == sizeof_field(union bpf_attr, numa_node),
		      "BPF_MAP_CREATE_struct.numa_node size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, numa_node) == offsetof(union bpf_attr, numa_node),
		      "BPF_MAP_CREATE_struct.numa_node offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_NUMA_NODE */

# ifdef HAVE_UNION_BPF_ATTR_MAP_NAME
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_name) == sizeof_field(union bpf_attr, map_name),
		      "BPF_MAP_CREATE_struct.map_name size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_name) == offsetof(union bpf_attr, map_name),
		      "BPF_MAP_CREATE_struct.map_name offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_NAME */

# ifdef HAVE_UNION_BPF_ATTR_MAP_IFINDEX
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_ifindex) == sizeof_field(union bpf_attr, map_ifindex),
		      "BPF_MAP_CREATE_struct.map_ifindex size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_ifindex) == offsetof(union bpf_attr, map_ifindex),
		      "BPF_MAP_CREATE_struct.map_ifindex offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_IFINDEX */

# ifdef HAVE_UNION_BPF_ATTR_BTF_FD
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_fd) == sizeof_field(union bpf_attr, btf_fd),
		      "BPF_MAP_CREATE_struct.btf_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_fd) == offsetof(union bpf_attr, btf_fd),
		      "BPF_MAP_CREATE_struct.btf_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_FD */

# ifdef HAVE_UNION_BPF_ATTR_BTF_KEY_TYPE_ID
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_key_type_id) == sizeof_field(union bpf_attr, btf_key_type_id),
		      "BPF_MAP_CREATE_struct.btf_key_type_id size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_key_type_id) == offsetof(union bpf_attr, btf_key_type_id),
		      "BPF_MAP_CREATE_struct.btf_key_type_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_KEY_TYPE_ID */

# ifdef HAVE_UNION_BPF_ATTR_BTF_VALUE_TYPE_ID
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_value_type_id) == sizeof_field(union bpf_attr, btf_value_type_id),
		      "BPF_MAP_CREATE_struct.btf_value_type_id size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_value_type_id) == offsetof(union bpf_attr, btf_value_type_id),
		      "BPF_MAP_CREATE_struct.btf_value_type_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_VALUE_TYPE_ID */

# ifdef HAVE_UNION_BPF_ATTR_BTF_VMLINUX_VALUE_TYPE_ID
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_vmlinux_value_type_id) == sizeof_field(union bpf_attr, btf_vmlinux_value_type_id),
		      "BPF_MAP_CREATE_struct.btf_vmlinux_value_type_id size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_vmlinux_value_type_id) == offsetof(union bpf_attr, btf_vmlinux_value_type_id),
		      "BPF_MAP_CREATE_struct.btf_vmlinux_value_type_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_VMLINUX_VALUE_TYPE_ID */

# ifdef HAVE_UNION_BPF_ATTR_MAP_EXTRA
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_extra) == sizeof_field(union bpf_attr, map_extra),
		      "BPF_MAP_CREATE_struct.map_extra size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_extra) == offsetof(union bpf_attr, map_extra),
		      "BPF_MAP_CREATE_struct.map_extra offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_EXTRA */

# ifdef HAVE_UNION_BPF_ATTR_VALUE_TYPE_BTF_OBJ_FD
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, value_type_btf_obj_fd) == sizeof_field(union bpf_attr, value_type_btf_obj_fd),
		      "BPF_MAP_CREATE_struct.value_type_btf_obj_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, value_type_btf_obj_fd) == offsetof(union bpf_attr, value_type_btf_obj_fd),
		      "BPF_MAP_CREATE_struct.value_type_btf_obj_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_VALUE_TYPE_BTF_OBJ_FD */

# ifdef HAVE_UNION_BPF_ATTR_MAP_TOKEN_FD
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_token_fd) == sizeof_field(union bpf_attr, map_token_fd),
		      "BPF_MAP_CREATE_struct.map_token_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_token_fd) == offsetof(union bpf_attr, map_token_fd),
		      "BPF_MAP_CREATE_struct.map_token_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_TOKEN_FD */

# ifdef HAVE_UNION_BPF_ATTR_EXCL_PROG_HASH
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, excl_prog_hash) == sizeof_field(union bpf_attr, excl_prog_hash),
		      "BPF_MAP_CREATE_struct.excl_prog_hash size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, excl_prog_hash) == offsetof(union bpf_attr, excl_prog_hash),
		      "BPF_MAP_CREATE_struct.excl_prog_hash offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_EXCL_PROG_HASH */

# ifdef HAVE_UNION_BPF_ATTR_EXCL_PROG_HASH_SIZE
	static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, excl_prog_hash_size) == sizeof_field(union bpf_attr, excl_prog_hash_size),
		      "BPF_MAP_CREATE_struct.excl_prog_hash_size size mismatch");
	static_assert(offsetof(struct BPF_MAP_CREATE_struct, excl_prog_hash_size) == offsetof(union bpf_attr, excl_prog_hash_size),
		      "BPF_MAP_CREATE_struct.excl_prog_hash_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_EXCL_PROG_HASH_SIZE */

static_assert(BPF_MAP_CREATE_struct_size == expected_BPF_MAP_CREATE_struct_size,
	      "BPF_MAP_CREATE_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_MAP_FD
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
		      "BPF_MAP_LOOKUP_ELEM_struct.map_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd),
		      "BPF_MAP_LOOKUP_ELEM_struct.map_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_FD */

# ifdef HAVE_UNION_BPF_ATTR_KEY
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, key) == sizeof_field(union bpf_attr, key),
		      "BPF_MAP_LOOKUP_ELEM_struct.key size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, key) == offsetof(union bpf_attr, key),
		      "BPF_MAP_LOOKUP_ELEM_struct.key offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_KEY */

# ifdef HAVE_UNION_BPF_ATTR_VALUE
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, value) == sizeof_field(union bpf_attr, value),
		      "BPF_MAP_LOOKUP_ELEM_struct.value size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, value) == offsetof(union bpf_attr, value),
		      "BPF_MAP_LOOKUP_ELEM_struct.value offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_VALUE */

# ifdef HAVE_UNION_BPF_ATTR_FLAGS
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, flags) == sizeof_field(union bpf_attr, flags),
		      "BPF_MAP_LOOKUP_ELEM_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, flags) == offsetof(union bpf_attr, flags),
		      "BPF_MAP_LOOKUP_ELEM_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FLAGS */

static_assert(BPF_MAP_LOOKUP_ELEM_struct_size == expected_BPF_MAP_LOOKUP_ELEM_struct_size,
	      "BPF_MAP_LOOKUP_ELEM_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_MAP_FD
	static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
		      "BPF_MAP_UPDATE_ELEM_struct.map_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd),
		      "BPF_MAP_UPDATE_ELEM_struct.map_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_FD */

# ifdef HAVE_UNION_BPF_ATTR_KEY
	static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, key) == sizeof_field(union bpf_attr, key),
		      "BPF_MAP_UPDATE_ELEM_struct.key size mismatch");
	static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, key) == offsetof(union bpf_attr, key),
		      "BPF_MAP_UPDATE_ELEM_struct.key offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_KEY */

# ifdef HAVE_UNION_BPF_ATTR_VALUE
	static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, value) == sizeof_field(union bpf_attr, value),
		      "BPF_MAP_UPDATE_ELEM_struct.value size mismatch");
	static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, value) == offsetof(union bpf_attr, value),
		      "BPF_MAP_UPDATE_ELEM_struct.value offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_VALUE */

# ifdef HAVE_UNION_BPF_ATTR_FLAGS
	static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, flags) == sizeof_field(union bpf_attr, flags),
		      "BPF_MAP_UPDATE_ELEM_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, flags) == offsetof(union bpf_attr, flags),
		      "BPF_MAP_UPDATE_ELEM_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FLAGS */

static_assert(BPF_MAP_UPDATE_ELEM_struct_size == expected_BPF_MAP_UPDATE_ELEM_struct_size,
	      "BPF_MAP_UPDATE_ELEM_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_MAP_FD
	static_assert(sizeof_field(struct BPF_MAP_DELETE_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
		      "BPF_MAP_DELETE_ELEM_struct.map_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_DELETE_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd),
		      "BPF_MAP_DELETE_ELEM_struct.map_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_FD */

# ifdef HAVE_UNION_BPF_ATTR_KEY
	static_assert(sizeof_field(struct BPF_MAP_DELETE_ELEM_struct, key) == sizeof_field(union bpf_attr, key),
		      "BPF_MAP_DELETE_ELEM_struct.key size mismatch");
	static_assert(offsetof(struct BPF_MAP_DELETE_ELEM_struct, key) == offsetof(union bpf_attr, key),
		      "BPF_MAP_DELETE_ELEM_struct.key offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_KEY */

static_assert(BPF_MAP_DELETE_ELEM_struct_size == expected_BPF_MAP_DELETE_ELEM_struct_size,
	      "BPF_MAP_DELETE_ELEM_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_MAP_FD
	static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
		      "BPF_MAP_GET_NEXT_KEY_struct.map_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, map_fd) == offsetof(union bpf_attr, map_fd),
		      "BPF_MAP_GET_NEXT_KEY_struct.map_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_FD */

# ifdef HAVE_UNION_BPF_ATTR_KEY
	static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, key) == sizeof_field(union bpf_attr, key),
		      "BPF_MAP_GET_NEXT_KEY_struct.key size mismatch");
	static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, key) == offsetof(union bpf_attr, key),
		      "BPF_MAP_GET_NEXT_KEY_struct.key offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_KEY */

# ifdef HAVE_UNION_BPF_ATTR_NEXT_KEY
	static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, next_key) == sizeof_field(union bpf_attr, next_key),
		      "BPF_MAP_GET_NEXT_KEY_struct.next_key size mismatch");
	static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, next_key) == offsetof(union bpf_attr, next_key),
		      "BPF_MAP_GET_NEXT_KEY_struct.next_key offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_NEXT_KEY */

static_assert(BPF_MAP_GET_NEXT_KEY_struct_size == expected_BPF_MAP_GET_NEXT_KEY_struct_size,
	      "BPF_MAP_GET_NEXT_KEY_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_MAP_FD
	static_assert(sizeof_field(struct BPF_MAP_FREEZE_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
		      "BPF_MAP_FREEZE_struct.map_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_FREEZE_struct, map_fd) == offsetof(union bpf_attr, map_fd),
		      "BPF_MAP_FREEZE_struct.map_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_FD */

static_assert(BPF_MAP_FREEZE_struct_size == expected_BPF_MAP_FREEZE_struct_size,
	      "BPF_MAP_FREEZE_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_PROG_TYPE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_type) == sizeof_field(union bpf_attr, prog_type),
		      "BPF_PROG_LOAD_struct.prog_type size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_type) == offsetof(union bpf_attr, prog_type),
		      "BPF_PROG_LOAD_struct.prog_type offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_TYPE */

# ifdef HAVE_UNION_BPF_ATTR_INSN_CNT
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, insn_cnt) == sizeof_field(union bpf_attr, insn_cnt),
		      "BPF_PROG_LOAD_struct.insn_cnt size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, insn_cnt) == offsetof(union bpf_attr, insn_cnt),
		      "BPF_PROG_LOAD_struct.insn_cnt offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_INSN_CNT */

# ifdef HAVE_UNION_BPF_ATTR_INSNS
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, insns) == sizeof_field(union bpf_attr, insns),
		      "BPF_PROG_LOAD_struct.insns size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, insns) == offsetof(union bpf_attr, insns),
		      "BPF_PROG_LOAD_struct.insns offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_INSNS */

# ifdef HAVE_UNION_BPF_ATTR_LICENSE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, license) == sizeof_field(union bpf_attr, license),
		      "BPF_PROG_LOAD_struct.license size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, license) == offsetof(union bpf_attr, license),
		      "BPF_PROG_LOAD_struct.license offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LICENSE */

# ifdef HAVE_UNION_BPF_ATTR_LOG_LEVEL
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_level) == sizeof_field(union bpf_attr, log_level),
		      "BPF_PROG_LOAD_struct.log_level size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_level) == offsetof(union bpf_attr, log_level),
		      "BPF_PROG_LOAD_struct.log_level offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LOG_LEVEL */

# ifdef HAVE_UNION_BPF_ATTR_LOG_SIZE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_size) == sizeof_field(union bpf_attr, log_size),
		      "BPF_PROG_LOAD_struct.log_size size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_size) == offsetof(union bpf_attr, log_size),
		      "BPF_PROG_LOAD_struct.log_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LOG_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_LOG_BUF
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_buf) == sizeof_field(union bpf_attr, log_buf),
		      "BPF_PROG_LOAD_struct.log_buf size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_buf) == offsetof(union bpf_attr, log_buf),
		      "BPF_PROG_LOAD_struct.log_buf offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LOG_BUF */

# ifdef HAVE_UNION_BPF_ATTR_KERN_VERSION
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, kern_version) == sizeof_field(union bpf_attr, kern_version),
		      "BPF_PROG_LOAD_struct.kern_version size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, kern_version) == offsetof(union bpf_attr, kern_version),
		      "BPF_PROG_LOAD_struct.kern_version offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_KERN_VERSION */

# ifdef HAVE_UNION_BPF_ATTR_PROG_FLAGS
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_flags) == sizeof_field(union bpf_attr, prog_flags),
		      "BPF_PROG_LOAD_struct.prog_flags size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_flags) == offsetof(union bpf_attr, prog_flags),
		      "BPF_PROG_LOAD_struct.prog_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_PROG_NAME
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_name) == sizeof_field(union bpf_attr, prog_name),
		      "BPF_PROG_LOAD_struct.prog_name size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_name) == offsetof(union bpf_attr, prog_name),
		      "BPF_PROG_LOAD_struct.prog_name offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_NAME */

# ifdef HAVE_UNION_BPF_ATTR_PROG_IFINDEX
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_ifindex) == sizeof_field(union bpf_attr, prog_ifindex),
		      "BPF_PROG_LOAD_struct.prog_ifindex size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_ifindex) == offsetof(union bpf_attr, prog_ifindex),
		      "BPF_PROG_LOAD_struct.prog_ifindex offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_IFINDEX */

# ifdef HAVE_UNION_BPF_ATTR_EXPECTED_ATTACH_TYPE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, expected_attach_type) == sizeof_field(union bpf_attr, expected_attach_type),
		      "BPF_PROG_LOAD_struct.expected_attach_type size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, expected_attach_type) == offsetof(union bpf_attr, expected_attach_type),
		      "BPF_PROG_LOAD_struct.expected_attach_type offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_EXPECTED_ATTACH_TYPE */

# ifdef HAVE_UNION_BPF_ATTR_PROG_BTF_FD
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_btf_fd) == sizeof_field(union bpf_attr, prog_btf_fd),
		      "BPF_PROG_LOAD_struct.prog_btf_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_btf_fd) == offsetof(union bpf_attr, prog_btf_fd),
		      "BPF_PROG_LOAD_struct.prog_btf_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_BTF_FD */

# ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO_REC_SIZE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info_rec_size) == sizeof_field(union bpf_attr, func_info_rec_size),
		      "BPF_PROG_LOAD_struct.func_info_rec_size size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info_rec_size) == offsetof(union bpf_attr, func_info_rec_size),
		      "BPF_PROG_LOAD_struct.func_info_rec_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO_REC_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info) == sizeof_field(union bpf_attr, func_info),
		      "BPF_PROG_LOAD_struct.func_info size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info) == offsetof(union bpf_attr, func_info),
		      "BPF_PROG_LOAD_struct.func_info offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO */

# ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO_CNT
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info_cnt) == sizeof_field(union bpf_attr, func_info_cnt),
		      "BPF_PROG_LOAD_struct.func_info_cnt size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info_cnt) == offsetof(union bpf_attr, func_info_cnt),
		      "BPF_PROG_LOAD_struct.func_info_cnt offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO_CNT */

# ifdef HAVE_UNION_BPF_ATTR_LINE_INFO_REC_SIZE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info_rec_size) == sizeof_field(union bpf_attr, line_info_rec_size),
		      "BPF_PROG_LOAD_struct.line_info_rec_size size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info_rec_size) == offsetof(union bpf_attr, line_info_rec_size),
		      "BPF_PROG_LOAD_struct.line_info_rec_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINE_INFO_REC_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_LINE_INFO
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info) == sizeof_field(union bpf_attr, line_info),
		      "BPF_PROG_LOAD_struct.line_info size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info) == offsetof(union bpf_attr, line_info),
		      "BPF_PROG_LOAD_struct.line_info offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINE_INFO */

# ifdef HAVE_UNION_BPF_ATTR_LINE_INFO_CNT
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info_cnt) == sizeof_field(union bpf_attr, line_info_cnt),
		      "BPF_PROG_LOAD_struct.line_info_cnt size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info_cnt) == offsetof(union bpf_attr, line_info_cnt),
		      "BPF_PROG_LOAD_struct.line_info_cnt offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINE_INFO_CNT */

# ifdef HAVE_UNION_BPF_ATTR_ATTACH_BTF_ID
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, attach_btf_id) == sizeof_field(union bpf_attr, attach_btf_id),
		      "BPF_PROG_LOAD_struct.attach_btf_id size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, attach_btf_id) == offsetof(union bpf_attr, attach_btf_id),
		      "BPF_PROG_LOAD_struct.attach_btf_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_ATTACH_BTF_ID */

# ifdef HAVE_UNION_BPF_ATTR_ATTACH_PROG_FD
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, attach_prog_fd) == sizeof_field(union bpf_attr, attach_prog_fd),
		      "BPF_PROG_LOAD_struct.attach_prog_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, attach_prog_fd) == offsetof(union bpf_attr, attach_prog_fd),
		      "BPF_PROG_LOAD_struct.attach_prog_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_ATTACH_PROG_FD */

# ifdef HAVE_UNION_BPF_ATTR_CORE_RELO_CNT
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, core_relo_cnt) == sizeof_field(union bpf_attr, core_relo_cnt),
		      "BPF_PROG_LOAD_struct.core_relo_cnt size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, core_relo_cnt) == offsetof(union bpf_attr, core_relo_cnt),
		      "BPF_PROG_LOAD_struct.core_relo_cnt offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_CORE_RELO_CNT */

# ifdef HAVE_UNION_BPF_ATTR_FD_ARRAY
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, fd_array) == sizeof_field(union bpf_attr, fd_array),
		      "BPF_PROG_LOAD_struct.fd_array size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, fd_array) == offsetof(union bpf_attr, fd_array),
		      "BPF_PROG_LOAD_struct.fd_array offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FD_ARRAY */

# ifdef HAVE_UNION_BPF_ATTR_CORE_RELOS
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, core_relos) == sizeof_field(union bpf_attr, core_relos),
		      "BPF_PROG_LOAD_struct.core_relos size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, core_relos) == offsetof(union bpf_attr, core_relos),
		      "BPF_PROG_LOAD_struct.core_relos offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_CORE_RELOS */

# ifdef HAVE_UNION_BPF_ATTR_CORE_RELO_REC_SIZE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, core_relo_rec_size) == sizeof_field(union bpf_attr, core_relo_rec_size),
		      "BPF_PROG_LOAD_struct.core_relo_rec_size size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, core_relo_rec_size) == offsetof(union bpf_attr, core_relo_rec_size),
		      "BPF_PROG_LOAD_struct.core_relo_rec_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_CORE_RELO_REC_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_LOG_TRUE_SIZE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_true_size) == sizeof_field(union bpf_attr, log_true_size),
		      "BPF_PROG_LOAD_struct.log_true_size size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_true_size) == offsetof(union bpf_attr, log_true_size),
		      "BPF_PROG_LOAD_struct.log_true_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LOG_TRUE_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_PROG_TOKEN_FD
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_token_fd) == sizeof_field(union bpf_attr, prog_token_fd),
		      "BPF_PROG_LOAD_struct.prog_token_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_token_fd) == offsetof(union bpf_attr, prog_token_fd),
		      "BPF_PROG_LOAD_struct.prog_token_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_TOKEN_FD */

# ifdef HAVE_UNION_BPF_ATTR_FD_ARRAY_CNT
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, fd_array_cnt) == sizeof_field(union bpf_attr, fd_array_cnt),
		      "BPF_PROG_LOAD_struct.fd_array_cnt size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, fd_array_cnt) == offsetof(union bpf_attr, fd_array_cnt),
		      "BPF_PROG_LOAD_struct.fd_array_cnt offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FD_ARRAY_CNT */

# ifdef HAVE_UNION_BPF_ATTR_SIGNATURE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, signature) == sizeof_field(union bpf_attr, signature),
		      "BPF_PROG_LOAD_struct.signature size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, signature) == offsetof(union bpf_attr, signature),
		      "BPF_PROG_LOAD_struct.signature offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_SIGNATURE */

# ifdef HAVE_UNION_BPF_ATTR_SIGNATURE_SIZE
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, signature_size) == sizeof_field(union bpf_attr, signature_size),
		      "BPF_PROG_LOAD_struct.signature_size size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, signature_size) == offsetof(union bpf_attr, signature_size),
		      "BPF_PROG_LOAD_struct.signature_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_SIGNATURE_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_KEYRING_ID
	static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, keyring_id) == sizeof_field(union bpf_attr, keyring_id),
		      "BPF_PROG_LOAD_struct.keyring_id size mismatch");
	static_assert(offsetof(struct BPF_PROG_LOAD_struct, keyring_id) == offsetof(union bpf_attr, keyring_id),
		      "BPF_PROG_LOAD_struct.keyring_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_KEYRING_ID */

static_assert(BPF_PROG_LOAD_struct_size == expected_BPF_PROG_LOAD_struct_size,
	      "BPF_PROG_LOAD_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_PATHNAME
	static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, pathname) == sizeof_field(union bpf_attr, pathname),
		      "BPF_OBJ_PIN_struct.pathname size mismatch");
	static_assert(offsetof(struct BPF_OBJ_PIN_struct, pathname) == offsetof(union bpf_attr, pathname),
		      "BPF_OBJ_PIN_struct.pathname offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PATHNAME */

# ifdef HAVE_UNION_BPF_ATTR_BPF_FD
	static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, bpf_fd) == sizeof_field(union bpf_attr, bpf_fd),
		      "BPF_OBJ_PIN_struct.bpf_fd size mismatch");
	static_assert(offsetof(struct BPF_OBJ_PIN_struct, bpf_fd) == offsetof(union bpf_attr, bpf_fd),
		      "BPF_OBJ_PIN_struct.bpf_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BPF_FD */

# ifdef HAVE_UNION_BPF_ATTR_FILE_FLAGS
	static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, file_flags) == sizeof_field(union bpf_attr, file_flags),
		      "BPF_OBJ_PIN_struct.file_flags size mismatch");
	static_assert(offsetof(struct BPF_OBJ_PIN_struct, file_flags) == offsetof(union bpf_attr, file_flags),
		      "BPF_OBJ_PIN_struct.file_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FILE_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_PATH_FD
	static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, path_fd) == sizeof_field(union bpf_attr, path_fd),
		      "BPF_OBJ_PIN_struct.path_fd size mismatch");
	static_assert(offsetof(struct BPF_OBJ_PIN_struct, path_fd) == offsetof(union bpf_attr, path_fd),
		      "BPF_OBJ_PIN_struct.path_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PATH_FD */

static_assert(BPF_OBJ_PIN_struct_size == expected_BPF_OBJ_PIN_struct_size,
	      "BPF_OBJ_PIN_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_TARGET_FD
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, target_fd) == sizeof_field(union bpf_attr, target_fd),
		      "BPF_PROG_ATTACH_struct.target_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, target_fd) == offsetof(union bpf_attr, target_fd),
		      "BPF_PROG_ATTACH_struct.target_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TARGET_FD */

# ifdef HAVE_UNION_BPF_ATTR_TARGET_IFINDEX
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, target_ifindex) == sizeof_field(union bpf_attr, target_ifindex),
		      "BPF_PROG_ATTACH_struct.target_ifindex size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, target_ifindex) == offsetof(union bpf_attr, target_ifindex),
		      "BPF_PROG_ATTACH_struct.target_ifindex offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TARGET_IFINDEX */

# ifdef HAVE_UNION_BPF_ATTR_ATTACH_BPF_FD
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_bpf_fd) == sizeof_field(union bpf_attr, attach_bpf_fd),
		      "BPF_PROG_ATTACH_struct.attach_bpf_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_bpf_fd) == offsetof(union bpf_attr, attach_bpf_fd),
		      "BPF_PROG_ATTACH_struct.attach_bpf_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_ATTACH_BPF_FD */

# ifdef HAVE_UNION_BPF_ATTR_ATTACH_TYPE
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_type) == sizeof_field(union bpf_attr, attach_type),
		      "BPF_PROG_ATTACH_struct.attach_type size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_type) == offsetof(union bpf_attr, attach_type),
		      "BPF_PROG_ATTACH_struct.attach_type offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_ATTACH_TYPE */

# ifdef HAVE_UNION_BPF_ATTR_ATTACH_FLAGS
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_flags) == sizeof_field(union bpf_attr, attach_flags),
		      "BPF_PROG_ATTACH_struct.attach_flags size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_flags) == offsetof(union bpf_attr, attach_flags),
		      "BPF_PROG_ATTACH_struct.attach_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_ATTACH_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_REPLACE_BPF_FD
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, replace_bpf_fd) == sizeof_field(union bpf_attr, replace_bpf_fd),
		      "BPF_PROG_ATTACH_struct.replace_bpf_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, replace_bpf_fd) == offsetof(union bpf_attr, replace_bpf_fd),
		      "BPF_PROG_ATTACH_struct.replace_bpf_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_REPLACE_BPF_FD */

# ifdef HAVE_UNION_BPF_ATTR_RELATIVE_FD
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, relative_fd) == sizeof_field(union bpf_attr, relative_fd),
		      "BPF_PROG_ATTACH_struct.relative_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, relative_fd) == offsetof(union bpf_attr, relative_fd),
		      "BPF_PROG_ATTACH_struct.relative_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_RELATIVE_FD */

# ifdef HAVE_UNION_BPF_ATTR_RELATIVE_ID
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, relative_id) == sizeof_field(union bpf_attr, relative_id),
		      "BPF_PROG_ATTACH_struct.relative_id size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, relative_id) == offsetof(union bpf_attr, relative_id),
		      "BPF_PROG_ATTACH_struct.relative_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_RELATIVE_ID */

# ifdef HAVE_UNION_BPF_ATTR_EXPECTED_REVISION
	static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, expected_revision) == sizeof_field(union bpf_attr, expected_revision),
		      "BPF_PROG_ATTACH_struct.expected_revision size mismatch");
	static_assert(offsetof(struct BPF_PROG_ATTACH_struct, expected_revision) == offsetof(union bpf_attr, expected_revision),
		      "BPF_PROG_ATTACH_struct.expected_revision offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_EXPECTED_REVISION */

static_assert(BPF_PROG_ATTACH_struct_size == expected_BPF_PROG_ATTACH_struct_size,
	      "BPF_PROG_ATTACH_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_TEST_PROG_FD
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, prog_fd) == sizeof_field(union bpf_attr, test.prog_fd),
		      "BPF_PROG_TEST_RUN_struct.prog_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, prog_fd) == offsetof(union bpf_attr, test.prog_fd),
		      "BPF_PROG_TEST_RUN_struct.prog_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_PROG_FD */

# ifdef HAVE_UNION_BPF_ATTR_TEST_RETVAL
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, retval) == sizeof_field(union bpf_attr, test.retval),
		      "BPF_PROG_TEST_RUN_struct.retval size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, retval) == offsetof(union bpf_attr, test.retval),
		      "BPF_PROG_TEST_RUN_struct.retval offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_RETVAL */

# ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_IN
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_size_in) == sizeof_field(union bpf_attr, test.data_size_in),
		      "BPF_PROG_TEST_RUN_struct.data_size_in size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_size_in) == offsetof(union bpf_attr, test.data_size_in),
		      "BPF_PROG_TEST_RUN_struct.data_size_in offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_IN */

# ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_OUT
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_size_out) == sizeof_field(union bpf_attr, test.data_size_out),
		      "BPF_PROG_TEST_RUN_struct.data_size_out size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_size_out) == offsetof(union bpf_attr, test.data_size_out),
		      "BPF_PROG_TEST_RUN_struct.data_size_out offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_OUT */

# ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_IN
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_in) == sizeof_field(union bpf_attr, test.data_in),
		      "BPF_PROG_TEST_RUN_struct.data_in size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_in) == offsetof(union bpf_attr, test.data_in),
		      "BPF_PROG_TEST_RUN_struct.data_in offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_IN */

# ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_OUT
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_out) == sizeof_field(union bpf_attr, test.data_out),
		      "BPF_PROG_TEST_RUN_struct.data_out size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_out) == offsetof(union bpf_attr, test.data_out),
		      "BPF_PROG_TEST_RUN_struct.data_out offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_OUT */

# ifdef HAVE_UNION_BPF_ATTR_TEST_REPEAT
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, repeat) == sizeof_field(union bpf_attr, test.repeat),
		      "BPF_PROG_TEST_RUN_struct.repeat size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, repeat) == offsetof(union bpf_attr, test.repeat),
		      "BPF_PROG_TEST_RUN_struct.repeat offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_REPEAT */

# ifdef HAVE_UNION_BPF_ATTR_TEST_DURATION
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, duration) == sizeof_field(union bpf_attr, test.duration),
		      "BPF_PROG_TEST_RUN_struct.duration size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, duration) == offsetof(union bpf_attr, test.duration),
		      "BPF_PROG_TEST_RUN_struct.duration offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_DURATION */

# ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_IN
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_size_in) == sizeof_field(union bpf_attr, test.ctx_size_in),
		      "BPF_PROG_TEST_RUN_struct.ctx_size_in size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_size_in) == offsetof(union bpf_attr, test.ctx_size_in),
		      "BPF_PROG_TEST_RUN_struct.ctx_size_in offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_IN */

# ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_OUT
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_size_out) == sizeof_field(union bpf_attr, test.ctx_size_out),
		      "BPF_PROG_TEST_RUN_struct.ctx_size_out size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_size_out) == offsetof(union bpf_attr, test.ctx_size_out),
		      "BPF_PROG_TEST_RUN_struct.ctx_size_out offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_OUT */

# ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_IN
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_in) == sizeof_field(union bpf_attr, test.ctx_in),
		      "BPF_PROG_TEST_RUN_struct.ctx_in size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_in) == offsetof(union bpf_attr, test.ctx_in),
		      "BPF_PROG_TEST_RUN_struct.ctx_in offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_IN */

# ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_OUT
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_out) == sizeof_field(union bpf_attr, test.ctx_out),
		      "BPF_PROG_TEST_RUN_struct.ctx_out size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_out) == offsetof(union bpf_attr, test.ctx_out),
		      "BPF_PROG_TEST_RUN_struct.ctx_out offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_OUT */

# ifdef HAVE_UNION_BPF_ATTR_TEST_FLAGS
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, flags) == sizeof_field(union bpf_attr, test.flags),
		      "BPF_PROG_TEST_RUN_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, flags) == offsetof(union bpf_attr, test.flags),
		      "BPF_PROG_TEST_RUN_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_TEST_CPU
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, cpu) == sizeof_field(union bpf_attr, test.cpu),
		      "BPF_PROG_TEST_RUN_struct.cpu size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, cpu) == offsetof(union bpf_attr, test.cpu),
		      "BPF_PROG_TEST_RUN_struct.cpu offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_CPU */

# ifdef HAVE_UNION_BPF_ATTR_TEST_BATCH_SIZE
	static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, batch_size) == sizeof_field(union bpf_attr, test.batch_size),
		      "BPF_PROG_TEST_RUN_struct.batch_size size mismatch");
	static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, batch_size) == offsetof(union bpf_attr, test.batch_size),
		      "BPF_PROG_TEST_RUN_struct.batch_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TEST_BATCH_SIZE */

static_assert(BPF_PROG_TEST_RUN_struct_size == expected_BPF_PROG_TEST_RUN_struct_size,
	      "BPF_PROG_TEST_RUN_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_START_ID
	static_assert(sizeof_field(struct BPF_PROG_GET_NEXT_ID_struct, start_id) == sizeof_field(union bpf_attr, start_id),
		      "BPF_PROG_GET_NEXT_ID_struct.start_id size mismatch");
	static_assert(offsetof(struct BPF_PROG_GET_NEXT_ID_struct, start_id) == offsetof(union bpf_attr, start_id),
		      "BPF_PROG_GET_NEXT_ID_struct.start_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_START_ID */

# ifdef HAVE_UNION_BPF_ATTR_NEXT_ID
	static_assert(sizeof_field(struct BPF_PROG_GET_NEXT_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id),
		      "BPF_PROG_GET_NEXT_ID_struct.next_id size mismatch");
	static_assert(offsetof(struct BPF_PROG_GET_NEXT_ID_struct, next_id) == offsetof(union bpf_attr, next_id),
		      "BPF_PROG_GET_NEXT_ID_struct.next_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */

static_assert(BPF_PROG_GET_NEXT_ID_struct_size == expected_BPF_PROG_GET_NEXT_ID_struct_size,
	      "BPF_PROG_GET_NEXT_ID_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_PROG_ID
	static_assert(sizeof_field(struct BPF_PROG_GET_FD_BY_ID_struct, prog_id) == sizeof_field(union bpf_attr, prog_id),
		      "BPF_PROG_GET_FD_BY_ID_struct.prog_id size mismatch");
	static_assert(offsetof(struct BPF_PROG_GET_FD_BY_ID_struct, prog_id) == offsetof(union bpf_attr, prog_id),
		      "BPF_PROG_GET_FD_BY_ID_struct.prog_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_ID */

static_assert(BPF_PROG_GET_FD_BY_ID_struct_size == expected_BPF_PROG_GET_FD_BY_ID_struct_size,
	      "BPF_PROG_GET_FD_BY_ID_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_MAP_ID
	static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, map_id) == sizeof_field(union bpf_attr, map_id),
		      "BPF_MAP_GET_FD_BY_ID_struct.map_id size mismatch");
	static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, map_id) == offsetof(union bpf_attr, map_id),
		      "BPF_MAP_GET_FD_BY_ID_struct.map_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_MAP_ID */

# ifdef HAVE_UNION_BPF_ATTR_NEXT_ID
	static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id),
		      "BPF_MAP_GET_FD_BY_ID_struct.next_id size mismatch");
	static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, next_id) == offsetof(union bpf_attr, next_id),
		      "BPF_MAP_GET_FD_BY_ID_struct.next_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */

# ifdef HAVE_UNION_BPF_ATTR_OPEN_FLAGS
	static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, open_flags) == sizeof_field(union bpf_attr, open_flags),
		      "BPF_MAP_GET_FD_BY_ID_struct.open_flags size mismatch");
	static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, open_flags) == offsetof(union bpf_attr, open_flags),
		      "BPF_MAP_GET_FD_BY_ID_struct.open_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_OPEN_FLAGS */

static_assert(BPF_MAP_GET_FD_BY_ID_struct_size == expected_BPF_MAP_GET_FD_BY_ID_struct_size,
	      "BPF_MAP_GET_FD_BY_ID_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_INFO_BPF_FD
	static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, bpf_fd) == sizeof_field(union bpf_attr, info.bpf_fd),
		      "BPF_OBJ_GET_INFO_BY_FD_struct.bpf_fd size mismatch");
	static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, bpf_fd) == offsetof(union bpf_attr, info.bpf_fd),
		      "BPF_OBJ_GET_INFO_BY_FD_struct.bpf_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_INFO_BPF_FD */

# ifdef HAVE_UNION_BPF_ATTR_INFO_INFO_LEN
	static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, info_len) == sizeof_field(union bpf_attr, info.info_len),
		      "BPF_OBJ_GET_INFO_BY_FD_struct.info_len size mismatch");
	static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, info_len) == offsetof(union bpf_attr, info.info_len),
		      "BPF_OBJ_GET_INFO_BY_FD_struct.info_len offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_INFO_INFO_LEN */

# ifdef HAVE_UNION_BPF_ATTR_INFO_INFO
	static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, info) == sizeof_field(union bpf_attr, info.info),
		      "BPF_OBJ_GET_INFO_BY_FD_struct.info size mismatch");
	static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, info) == offsetof(union bpf_attr, info.info),
		      "BPF_OBJ_GET_INFO_BY_FD_struct.info offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_INFO_INFO */

static_assert(BPF_OBJ_GET_INFO_BY_FD_struct_size == expected_BPF_OBJ_GET_INFO_BY_FD_struct_size,
	      "BPF_OBJ_GET_INFO_BY_FD_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_QUERY_TARGET_FD
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, target_fd) == sizeof_field(union bpf_attr, query.target_fd),
		      "BPF_PROG_QUERY_struct.target_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, target_fd) == offsetof(union bpf_attr, query.target_fd),
		      "BPF_PROG_QUERY_struct.target_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_TARGET_FD */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_TARGET_IFINDEX
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, target_ifindex) == sizeof_field(union bpf_attr, query.target_ifindex),
		      "BPF_PROG_QUERY_struct.target_ifindex size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, target_ifindex) == offsetof(union bpf_attr, query.target_ifindex),
		      "BPF_PROG_QUERY_struct.target_ifindex offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_TARGET_IFINDEX */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_ATTACH_TYPE
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, attach_type) == sizeof_field(union bpf_attr, query.attach_type),
		      "BPF_PROG_QUERY_struct.attach_type size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, attach_type) == offsetof(union bpf_attr, query.attach_type),
		      "BPF_PROG_QUERY_struct.attach_type offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_ATTACH_TYPE */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_QUERY_FLAGS
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, query_flags) == sizeof_field(union bpf_attr, query.query_flags),
		      "BPF_PROG_QUERY_struct.query_flags size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, query_flags) == offsetof(union bpf_attr, query.query_flags),
		      "BPF_PROG_QUERY_struct.query_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_QUERY_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_ATTACH_FLAGS
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, attach_flags) == sizeof_field(union bpf_attr, query.attach_flags),
		      "BPF_PROG_QUERY_struct.attach_flags size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, attach_flags) == offsetof(union bpf_attr, query.attach_flags),
		      "BPF_PROG_QUERY_struct.attach_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_ATTACH_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_PROG_IDS
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, prog_ids) == sizeof_field(union bpf_attr, query.prog_ids),
		      "BPF_PROG_QUERY_struct.prog_ids size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, prog_ids) == offsetof(union bpf_attr, query.prog_ids),
		      "BPF_PROG_QUERY_struct.prog_ids offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_PROG_IDS */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_PROG_CNT
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, prog_cnt) == sizeof_field(union bpf_attr, query.prog_cnt),
		      "BPF_PROG_QUERY_struct.prog_cnt size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, prog_cnt) == offsetof(union bpf_attr, query.prog_cnt),
		      "BPF_PROG_QUERY_struct.prog_cnt offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_PROG_CNT */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_DUMMY
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, dummy) == sizeof_field(union bpf_attr, query.dummy),
		      "BPF_PROG_QUERY_struct.dummy size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, dummy) == offsetof(union bpf_attr, query.dummy),
		      "BPF_PROG_QUERY_struct.dummy offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_DUMMY */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_PROG_ATTACH_FLAGS
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, prog_attach_flags) == sizeof_field(union bpf_attr, query.prog_attach_flags),
		      "BPF_PROG_QUERY_struct.prog_attach_flags size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, prog_attach_flags) == offsetof(union bpf_attr, query.prog_attach_flags),
		      "BPF_PROG_QUERY_struct.prog_attach_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_PROG_ATTACH_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_LINK_IDS
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, link_ids) == sizeof_field(union bpf_attr, query.link_ids),
		      "BPF_PROG_QUERY_struct.link_ids size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, link_ids) == offsetof(union bpf_attr, query.link_ids),
		      "BPF_PROG_QUERY_struct.link_ids offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_LINK_IDS */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_LINK_ATTACH_FLAGS
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, link_attach_flags) == sizeof_field(union bpf_attr, query.link_attach_flags),
		      "BPF_PROG_QUERY_struct.link_attach_flags size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, link_attach_flags) == offsetof(union bpf_attr, query.link_attach_flags),
		      "BPF_PROG_QUERY_struct.link_attach_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_LINK_ATTACH_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_QUERY_REVISION
	static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, revision) == sizeof_field(union bpf_attr, query.revision),
		      "BPF_PROG_QUERY_struct.revision size mismatch");
	static_assert(offsetof(struct BPF_PROG_QUERY_struct, revision) == offsetof(union bpf_attr, query.revision),
		      "BPF_PROG_QUERY_struct.revision offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_QUERY_REVISION */

static_assert(BPF_PROG_QUERY_struct_size == expected_BPF_PROG_QUERY_struct_size,
	      "BPF_PROG_QUERY_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_NAME
	static_assert(sizeof_field(struct BPF_RAW_TRACEPOINT_OPEN_struct, name) == sizeof_field(union bpf_attr, raw_tracepoint.name),
		      "BPF_RAW_TRACEPOINT_OPEN_struct.name size mismatch");
	static_assert(offsetof(struct BPF_RAW_TRACEPOINT_OPEN_struct, name) == offsetof(union bpf_attr, raw_tracepoint.name),
		      "BPF_RAW_TRACEPOINT_OPEN_struct.name offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_NAME */

# ifdef HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_PROG_FD
	static_assert(sizeof_field(struct BPF_RAW_TRACEPOINT_OPEN_struct, prog_fd) == sizeof_field(union bpf_attr, raw_tracepoint.prog_fd),
		      "BPF_RAW_TRACEPOINT_OPEN_struct.prog_fd size mismatch");
	static_assert(offsetof(struct BPF_RAW_TRACEPOINT_OPEN_struct, prog_fd) == offsetof(union bpf_attr, raw_tracepoint.prog_fd),
		      "BPF_RAW_TRACEPOINT_OPEN_struct.prog_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_PROG_FD */

# ifdef HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_DUMMY
	static_assert(sizeof_field(struct BPF_RAW_TRACEPOINT_OPEN_struct, dummy) == sizeof_field(union bpf_attr, raw_tracepoint.dummy),
		      "BPF_RAW_TRACEPOINT_OPEN_struct.dummy size mismatch");
	static_assert(offsetof(struct BPF_RAW_TRACEPOINT_OPEN_struct, dummy) == offsetof(union bpf_attr, raw_tracepoint.dummy),
		      "BPF_RAW_TRACEPOINT_OPEN_struct.dummy offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_DUMMY */

# ifdef HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_COOKIE
	static_assert(sizeof_field(struct BPF_RAW_TRACEPOINT_OPEN_struct, cookie) == sizeof_field(union bpf_attr, raw_tracepoint.cookie),
		      "BPF_RAW_TRACEPOINT_OPEN_struct.cookie size mismatch");
	static_assert(offsetof(struct BPF_RAW_TRACEPOINT_OPEN_struct, cookie) == offsetof(union bpf_attr, raw_tracepoint.cookie),
		      "BPF_RAW_TRACEPOINT_OPEN_struct.cookie offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_COOKIE */

static_assert(BPF_RAW_TRACEPOINT_OPEN_struct_size == expected_BPF_RAW_TRACEPOINT_OPEN_struct_size,
	      "BPF_RAW_TRACEPOINT_OPEN_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_BTF
	static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf) == sizeof_field(union bpf_attr, btf),
		      "BPF_BTF_LOAD_struct.btf size mismatch");
	static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf) == offsetof(union bpf_attr, btf),
		      "BPF_BTF_LOAD_struct.btf offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF */

# ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_BUF
	static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_buf) == sizeof_field(union bpf_attr, btf_log_buf),
		      "BPF_BTF_LOAD_struct.btf_log_buf size mismatch");
	static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_buf) == offsetof(union bpf_attr, btf_log_buf),
		      "BPF_BTF_LOAD_struct.btf_log_buf offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_BUF */

# ifdef HAVE_UNION_BPF_ATTR_BTF_SIZE
	static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_size) == sizeof_field(union bpf_attr, btf_size),
		      "BPF_BTF_LOAD_struct.btf_size size mismatch");
	static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_size) == offsetof(union bpf_attr, btf_size),
		      "BPF_BTF_LOAD_struct.btf_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_SIZE
	static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_size) == sizeof_field(union bpf_attr, btf_log_size),
		      "BPF_BTF_LOAD_struct.btf_log_size size mismatch");
	static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_size) == offsetof(union bpf_attr, btf_log_size),
		      "BPF_BTF_LOAD_struct.btf_log_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_LEVEL
	static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_level) == sizeof_field(union bpf_attr, btf_log_level),
		      "BPF_BTF_LOAD_struct.btf_log_level size mismatch");
	static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_level) == offsetof(union bpf_attr, btf_log_level),
		      "BPF_BTF_LOAD_struct.btf_log_level offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_LEVEL */

# ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_TRUE_SIZE
	static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_true_size) == sizeof_field(union bpf_attr, btf_log_true_size),
		      "BPF_BTF_LOAD_struct.btf_log_true_size size mismatch");
	static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_true_size) == offsetof(union bpf_attr, btf_log_true_size),
		      "BPF_BTF_LOAD_struct.btf_log_true_size offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_TRUE_SIZE */

# ifdef HAVE_UNION_BPF_ATTR_BTF_FLAGS
	static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_flags) == sizeof_field(union bpf_attr, btf_flags),
		      "BPF_BTF_LOAD_struct.btf_flags size mismatch");
	static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_flags) == offsetof(union bpf_attr, btf_flags),
		      "BPF_BTF_LOAD_struct.btf_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_BTF_TOKEN_FD
	static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_token_fd) == sizeof_field(union bpf_attr, btf_token_fd),
		      "BPF_BTF_LOAD_struct.btf_token_fd size mismatch");
	static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_token_fd) == offsetof(union bpf_attr, btf_token_fd),
		      "BPF_BTF_LOAD_struct.btf_token_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_TOKEN_FD */

static_assert(BPF_BTF_LOAD_struct_size == expected_BPF_BTF_LOAD_struct_size,
	      "BPF_BTF_LOAD_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_BTF_ID
	static_assert(sizeof_field(struct BPF_BTF_GET_FD_BY_ID_struct, btf_id) == sizeof_field(union bpf_attr, btf_id),
		      "BPF_BTF_GET_FD_BY_ID_struct.btf_id size mismatch");
	static_assert(offsetof(struct BPF_BTF_GET_FD_BY_ID_struct, btf_id) == offsetof(union bpf_attr, btf_id),
		      "BPF_BTF_GET_FD_BY_ID_struct.btf_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BTF_ID */

# ifdef HAVE_UNION_BPF_ATTR_NEXT_ID
	static_assert(sizeof_field(struct BPF_BTF_GET_FD_BY_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id),
		      "BPF_BTF_GET_FD_BY_ID_struct.next_id size mismatch");
	static_assert(offsetof(struct BPF_BTF_GET_FD_BY_ID_struct, next_id) == offsetof(union bpf_attr, next_id),
		      "BPF_BTF_GET_FD_BY_ID_struct.next_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */

# ifdef HAVE_UNION_BPF_ATTR_OPEN_FLAGS
	static_assert(sizeof_field(struct BPF_BTF_GET_FD_BY_ID_struct, open_flags) == sizeof_field(union bpf_attr, open_flags),
		      "BPF_BTF_GET_FD_BY_ID_struct.open_flags size mismatch");
	static_assert(offsetof(struct BPF_BTF_GET_FD_BY_ID_struct, open_flags) == offsetof(union bpf_attr, open_flags),
		      "BPF_BTF_GET_FD_BY_ID_struct.open_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_OPEN_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_FD_BY_ID_TOKEN_FD
	static_assert(sizeof_field(struct BPF_BTF_GET_FD_BY_ID_struct, fd_by_id_token_fd) == sizeof_field(union bpf_attr, fd_by_id_token_fd),
		      "BPF_BTF_GET_FD_BY_ID_struct.fd_by_id_token_fd size mismatch");
	static_assert(offsetof(struct BPF_BTF_GET_FD_BY_ID_struct, fd_by_id_token_fd) == offsetof(union bpf_attr, fd_by_id_token_fd),
		      "BPF_BTF_GET_FD_BY_ID_struct.fd_by_id_token_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_FD_BY_ID_TOKEN_FD */

static_assert(BPF_BTF_GET_FD_BY_ID_struct_size == expected_BPF_BTF_GET_FD_BY_ID_struct_size,
	      "BPF_BTF_GET_FD_BY_ID_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PID
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, pid) == sizeof_field(union bpf_attr, task_fd_query.pid),
		      "BPF_TASK_FD_QUERY_struct.pid size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, pid) == offsetof(union bpf_attr, task_fd_query.pid),
		      "BPF_TASK_FD_QUERY_struct.pid offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PID */

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, fd) == sizeof_field(union bpf_attr, task_fd_query.fd),
		      "BPF_TASK_FD_QUERY_struct.fd size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, fd) == offsetof(union bpf_attr, task_fd_query.fd),
		      "BPF_TASK_FD_QUERY_struct.fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD */

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FLAGS
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, flags) == sizeof_field(union bpf_attr, task_fd_query.flags),
		      "BPF_TASK_FD_QUERY_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, flags) == offsetof(union bpf_attr, task_fd_query.flags),
		      "BPF_TASK_FD_QUERY_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF_LEN
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, buf_len) == sizeof_field(union bpf_attr, task_fd_query.buf_len),
		      "BPF_TASK_FD_QUERY_struct.buf_len size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, buf_len) == offsetof(union bpf_attr, task_fd_query.buf_len),
		      "BPF_TASK_FD_QUERY_struct.buf_len offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF_LEN */

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, buf) == sizeof_field(union bpf_attr, task_fd_query.buf),
		      "BPF_TASK_FD_QUERY_struct.buf size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, buf) == offsetof(union bpf_attr, task_fd_query.buf),
		      "BPF_TASK_FD_QUERY_struct.buf offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF */

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROG_ID
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, prog_id) == sizeof_field(union bpf_attr, task_fd_query.prog_id),
		      "BPF_TASK_FD_QUERY_struct.prog_id size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, prog_id) == offsetof(union bpf_attr, task_fd_query.prog_id),
		      "BPF_TASK_FD_QUERY_struct.prog_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROG_ID */

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD_TYPE
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, fd_type) == sizeof_field(union bpf_attr, task_fd_query.fd_type),
		      "BPF_TASK_FD_QUERY_struct.fd_type size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, fd_type) == offsetof(union bpf_attr, task_fd_query.fd_type),
		      "BPF_TASK_FD_QUERY_struct.fd_type offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD_TYPE */

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_OFFSET
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, probe_offset) == sizeof_field(union bpf_attr, task_fd_query.probe_offset),
		      "BPF_TASK_FD_QUERY_struct.probe_offset size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, probe_offset) == offsetof(union bpf_attr, task_fd_query.probe_offset),
		      "BPF_TASK_FD_QUERY_struct.probe_offset offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_OFFSET */

# ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_ADDR
	static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, probe_addr) == sizeof_field(union bpf_attr, task_fd_query.probe_addr),
		      "BPF_TASK_FD_QUERY_struct.probe_addr size mismatch");
	static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, probe_addr) == offsetof(union bpf_attr, task_fd_query.probe_addr),
		      "BPF_TASK_FD_QUERY_struct.probe_addr offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_ADDR */

static_assert(BPF_TASK_FD_QUERY_struct_size == expected_BPF_TASK_FD_QUERY_struct_size,
	      "BPF_TASK_FD_QUERY_struct_size mismatch");

# ifdef HAVE_STRUCT_BPF_MAP_INFO_TYPE
	static_assert(sizeof_field(struct bpf_map_info_struct, type) == sizeof_field(struct bpf_map_info, type),
		      "bpf_map_info_struct.type size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, type) == offsetof(struct bpf_map_info, type),
		      "bpf_map_info_struct.type offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_TYPE */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_ID
	static_assert(sizeof_field(struct bpf_map_info_struct, id) == sizeof_field(struct bpf_map_info, id),
		      "bpf_map_info_struct.id size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, id) == offsetof(struct bpf_map_info, id),
		      "bpf_map_info_struct.id offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_ID */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_KEY_SIZE
	static_assert(sizeof_field(struct bpf_map_info_struct, key_size) == sizeof_field(struct bpf_map_info, key_size),
		      "bpf_map_info_struct.key_size size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, key_size) == offsetof(struct bpf_map_info, key_size),
		      "bpf_map_info_struct.key_size offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_KEY_SIZE */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_VALUE_SIZE
	static_assert(sizeof_field(struct bpf_map_info_struct, value_size) == sizeof_field(struct bpf_map_info, value_size),
		      "bpf_map_info_struct.value_size size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, value_size) == offsetof(struct bpf_map_info, value_size),
		      "bpf_map_info_struct.value_size offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_VALUE_SIZE */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_MAX_ENTRIES
	static_assert(sizeof_field(struct bpf_map_info_struct, max_entries) == sizeof_field(struct bpf_map_info, max_entries),
		      "bpf_map_info_struct.max_entries size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, max_entries) == offsetof(struct bpf_map_info, max_entries),
		      "bpf_map_info_struct.max_entries offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_MAX_ENTRIES */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_MAP_FLAGS
	static_assert(sizeof_field(struct bpf_map_info_struct, map_flags) == sizeof_field(struct bpf_map_info, map_flags),
		      "bpf_map_info_struct.map_flags size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, map_flags) == offsetof(struct bpf_map_info, map_flags),
		      "bpf_map_info_struct.map_flags offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_MAP_FLAGS */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_NAME
	static_assert(sizeof_field(struct bpf_map_info_struct, name) == sizeof_field(struct bpf_map_info, name),
		      "bpf_map_info_struct.name size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, name) == offsetof(struct bpf_map_info, name),
		      "bpf_map_info_struct.name offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_NAME */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_IFINDEX
	static_assert(sizeof_field(struct bpf_map_info_struct, ifindex) == sizeof_field(struct bpf_map_info, ifindex),
		      "bpf_map_info_struct.ifindex size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, ifindex) == offsetof(struct bpf_map_info, ifindex),
		      "bpf_map_info_struct.ifindex offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_IFINDEX */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_VMLINUX_VALUE_TYPE_ID
	static_assert(sizeof_field(struct bpf_map_info_struct, btf_vmlinux_value_type_id) == sizeof_field(struct bpf_map_info, btf_vmlinux_value_type_id),
		      "bpf_map_info_struct.btf_vmlinux_value_type_id size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, btf_vmlinux_value_type_id) == offsetof(struct bpf_map_info, btf_vmlinux_value_type_id),
		      "bpf_map_info_struct.btf_vmlinux_value_type_id offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_VMLINUX_VALUE_TYPE_ID */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_ID
	static_assert(sizeof_field(struct bpf_map_info_struct, btf_id) == sizeof_field(struct bpf_map_info, btf_id),
		      "bpf_map_info_struct.btf_id size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, btf_id) == offsetof(struct bpf_map_info, btf_id),
		      "bpf_map_info_struct.btf_id offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_ID */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_KEY_TYPE_ID
	static_assert(sizeof_field(struct bpf_map_info_struct, btf_key_type_id) == sizeof_field(struct bpf_map_info, btf_key_type_id),
		      "bpf_map_info_struct.btf_key_type_id size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, btf_key_type_id) == offsetof(struct bpf_map_info, btf_key_type_id),
		      "bpf_map_info_struct.btf_key_type_id offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_KEY_TYPE_ID */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_VALUE_TYPE_ID
	static_assert(sizeof_field(struct bpf_map_info_struct, btf_value_type_id) == sizeof_field(struct bpf_map_info, btf_value_type_id),
		      "bpf_map_info_struct.btf_value_type_id size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, btf_value_type_id) == offsetof(struct bpf_map_info, btf_value_type_id),
		      "bpf_map_info_struct.btf_value_type_id offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_VALUE_TYPE_ID */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_VMLINUX_ID
	static_assert(sizeof_field(struct bpf_map_info_struct, btf_vmlinux_id) == sizeof_field(struct bpf_map_info, btf_vmlinux_id),
		      "bpf_map_info_struct.btf_vmlinux_id size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, btf_vmlinux_id) == offsetof(struct bpf_map_info, btf_vmlinux_id),
		      "bpf_map_info_struct.btf_vmlinux_id offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_VMLINUX_ID */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_MAP_EXTRA
	static_assert(sizeof_field(struct bpf_map_info_struct, map_extra) == sizeof_field(struct bpf_map_info, map_extra),
		      "bpf_map_info_struct.map_extra size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, map_extra) == offsetof(struct bpf_map_info, map_extra),
		      "bpf_map_info_struct.map_extra offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_MAP_EXTRA */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_HASH
	static_assert(sizeof_field(struct bpf_map_info_struct, hash) == sizeof_field(struct bpf_map_info, hash),
		      "bpf_map_info_struct.hash size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, hash) == offsetof(struct bpf_map_info, hash),
		      "bpf_map_info_struct.hash offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_HASH */

# ifdef HAVE_STRUCT_BPF_MAP_INFO_HASH_SIZE
	static_assert(sizeof_field(struct bpf_map_info_struct, hash_size) == sizeof_field(struct bpf_map_info, hash_size),
		      "bpf_map_info_struct.hash_size size mismatch");
	static_assert(offsetof(struct bpf_map_info_struct, hash_size) == offsetof(struct bpf_map_info, hash_size),
		      "bpf_map_info_struct.hash_size offset mismatch");
# endif /* HAVE_STRUCT_BPF_MAP_INFO_HASH_SIZE */

static_assert(bpf_map_info_struct_size == expected_bpf_map_info_struct_size,
	      "bpf_map_info_struct_size mismatch");

# ifdef HAVE_STRUCT_BPF_PROG_INFO_TYPE
	static_assert(sizeof_field(struct bpf_prog_info_struct, type) == sizeof_field(struct bpf_prog_info, type),
		      "bpf_prog_info_struct.type size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, type) == offsetof(struct bpf_prog_info, type),
		      "bpf_prog_info_struct.type offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_TYPE */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_ID
	static_assert(sizeof_field(struct bpf_prog_info_struct, id) == sizeof_field(struct bpf_prog_info, id),
		      "bpf_prog_info_struct.id size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, id) == offsetof(struct bpf_prog_info, id),
		      "bpf_prog_info_struct.id offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_ID */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_TAG
	static_assert(sizeof_field(struct bpf_prog_info_struct, tag) == sizeof_field(struct bpf_prog_info, tag),
		      "bpf_prog_info_struct.tag size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, tag) == offsetof(struct bpf_prog_info, tag),
		      "bpf_prog_info_struct.tag offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_TAG */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_LEN
	static_assert(sizeof_field(struct bpf_prog_info_struct, jited_prog_len) == sizeof_field(struct bpf_prog_info, jited_prog_len),
		      "bpf_prog_info_struct.jited_prog_len size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, jited_prog_len) == offsetof(struct bpf_prog_info, jited_prog_len),
		      "bpf_prog_info_struct.jited_prog_len offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_LEN */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_LEN
	static_assert(sizeof_field(struct bpf_prog_info_struct, xlated_prog_len) == sizeof_field(struct bpf_prog_info, xlated_prog_len),
		      "bpf_prog_info_struct.xlated_prog_len size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, xlated_prog_len) == offsetof(struct bpf_prog_info, xlated_prog_len),
		      "bpf_prog_info_struct.xlated_prog_len offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_LEN */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_INSNS
	static_assert(sizeof_field(struct bpf_prog_info_struct, jited_prog_insns) == sizeof_field(struct bpf_prog_info, jited_prog_insns),
		      "bpf_prog_info_struct.jited_prog_insns size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, jited_prog_insns) == offsetof(struct bpf_prog_info, jited_prog_insns),
		      "bpf_prog_info_struct.jited_prog_insns offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_INSNS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_INSNS
	static_assert(sizeof_field(struct bpf_prog_info_struct, xlated_prog_insns) == sizeof_field(struct bpf_prog_info, xlated_prog_insns),
		      "bpf_prog_info_struct.xlated_prog_insns size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, xlated_prog_insns) == offsetof(struct bpf_prog_info, xlated_prog_insns),
		      "bpf_prog_info_struct.xlated_prog_insns offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_INSNS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_LOAD_TIME
	static_assert(sizeof_field(struct bpf_prog_info_struct, load_time) == sizeof_field(struct bpf_prog_info, load_time),
		      "bpf_prog_info_struct.load_time size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, load_time) == offsetof(struct bpf_prog_info, load_time),
		      "bpf_prog_info_struct.load_time offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_LOAD_TIME */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_CREATED_BY_UID
	static_assert(sizeof_field(struct bpf_prog_info_struct, created_by_uid) == sizeof_field(struct bpf_prog_info, created_by_uid),
		      "bpf_prog_info_struct.created_by_uid size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, created_by_uid) == offsetof(struct bpf_prog_info, created_by_uid),
		      "bpf_prog_info_struct.created_by_uid offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_CREATED_BY_UID */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_MAP_IDS
	static_assert(sizeof_field(struct bpf_prog_info_struct, nr_map_ids) == sizeof_field(struct bpf_prog_info, nr_map_ids),
		      "bpf_prog_info_struct.nr_map_ids size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, nr_map_ids) == offsetof(struct bpf_prog_info, nr_map_ids),
		      "bpf_prog_info_struct.nr_map_ids offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_MAP_IDS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_MAP_IDS
	static_assert(sizeof_field(struct bpf_prog_info_struct, map_ids) == sizeof_field(struct bpf_prog_info, map_ids),
		      "bpf_prog_info_struct.map_ids size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, map_ids) == offsetof(struct bpf_prog_info, map_ids),
		      "bpf_prog_info_struct.map_ids offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_MAP_IDS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_NAME
	static_assert(sizeof_field(struct bpf_prog_info_struct, name) == sizeof_field(struct bpf_prog_info, name),
		      "bpf_prog_info_struct.name size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, name) == offsetof(struct bpf_prog_info, name),
		      "bpf_prog_info_struct.name offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_NAME */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_IFINDEX
	static_assert(sizeof_field(struct bpf_prog_info_struct, ifindex) == sizeof_field(struct bpf_prog_info, ifindex),
		      "bpf_prog_info_struct.ifindex size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, ifindex) == offsetof(struct bpf_prog_info, ifindex),
		      "bpf_prog_info_struct.ifindex offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_IFINDEX */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_KSYMS
	static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_ksyms) == sizeof_field(struct bpf_prog_info, nr_jited_ksyms),
		      "bpf_prog_info_struct.nr_jited_ksyms size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_ksyms) == offsetof(struct bpf_prog_info, nr_jited_ksyms),
		      "bpf_prog_info_struct.nr_jited_ksyms offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_KSYMS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_FUNC_LENS
	static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_func_lens) == sizeof_field(struct bpf_prog_info, nr_jited_func_lens),
		      "bpf_prog_info_struct.nr_jited_func_lens size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_func_lens) == offsetof(struct bpf_prog_info, nr_jited_func_lens),
		      "bpf_prog_info_struct.nr_jited_func_lens offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_FUNC_LENS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_KSYMS
	static_assert(sizeof_field(struct bpf_prog_info_struct, jited_ksyms) == sizeof_field(struct bpf_prog_info, jited_ksyms),
		      "bpf_prog_info_struct.jited_ksyms size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, jited_ksyms) == offsetof(struct bpf_prog_info, jited_ksyms),
		      "bpf_prog_info_struct.jited_ksyms offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_KSYMS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_FUNC_LENS
	static_assert(sizeof_field(struct bpf_prog_info_struct, jited_func_lens) == sizeof_field(struct bpf_prog_info, jited_func_lens),
		      "bpf_prog_info_struct.jited_func_lens size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, jited_func_lens) == offsetof(struct bpf_prog_info, jited_func_lens),
		      "bpf_prog_info_struct.jited_func_lens offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_FUNC_LENS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_BTF_ID
	static_assert(sizeof_field(struct bpf_prog_info_struct, btf_id) == sizeof_field(struct bpf_prog_info, btf_id),
		      "bpf_prog_info_struct.btf_id size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, btf_id) == offsetof(struct bpf_prog_info, btf_id),
		      "bpf_prog_info_struct.btf_id offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_BTF_ID */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO_REC_SIZE
	static_assert(sizeof_field(struct bpf_prog_info_struct, func_info_rec_size) == sizeof_field(struct bpf_prog_info, func_info_rec_size),
		      "bpf_prog_info_struct.func_info_rec_size size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, func_info_rec_size) == offsetof(struct bpf_prog_info, func_info_rec_size),
		      "bpf_prog_info_struct.func_info_rec_size offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO_REC_SIZE */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO
	static_assert(sizeof_field(struct bpf_prog_info_struct, func_info) == sizeof_field(struct bpf_prog_info, func_info),
		      "bpf_prog_info_struct.func_info size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, func_info) == offsetof(struct bpf_prog_info, func_info),
		      "bpf_prog_info_struct.func_info offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_FUNC_INFO
	static_assert(sizeof_field(struct bpf_prog_info_struct, nr_func_info) == sizeof_field(struct bpf_prog_info, nr_func_info),
		      "bpf_prog_info_struct.nr_func_info size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, nr_func_info) == offsetof(struct bpf_prog_info, nr_func_info),
		      "bpf_prog_info_struct.nr_func_info offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_FUNC_INFO */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_LINE_INFO
	static_assert(sizeof_field(struct bpf_prog_info_struct, nr_line_info) == sizeof_field(struct bpf_prog_info, nr_line_info),
		      "bpf_prog_info_struct.nr_line_info size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, nr_line_info) == offsetof(struct bpf_prog_info, nr_line_info),
		      "bpf_prog_info_struct.nr_line_info offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_LINE_INFO */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO
	static_assert(sizeof_field(struct bpf_prog_info_struct, line_info) == sizeof_field(struct bpf_prog_info, line_info),
		      "bpf_prog_info_struct.line_info size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, line_info) == offsetof(struct bpf_prog_info, line_info),
		      "bpf_prog_info_struct.line_info offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO
	static_assert(sizeof_field(struct bpf_prog_info_struct, jited_line_info) == sizeof_field(struct bpf_prog_info, jited_line_info),
		      "bpf_prog_info_struct.jited_line_info size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, jited_line_info) == offsetof(struct bpf_prog_info, jited_line_info),
		      "bpf_prog_info_struct.jited_line_info offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_LINE_INFO
	static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_line_info) == sizeof_field(struct bpf_prog_info, nr_jited_line_info),
		      "bpf_prog_info_struct.nr_jited_line_info size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_line_info) == offsetof(struct bpf_prog_info, nr_jited_line_info),
		      "bpf_prog_info_struct.nr_jited_line_info offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_LINE_INFO */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO_REC_SIZE
	static_assert(sizeof_field(struct bpf_prog_info_struct, line_info_rec_size) == sizeof_field(struct bpf_prog_info, line_info_rec_size),
		      "bpf_prog_info_struct.line_info_rec_size size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, line_info_rec_size) == offsetof(struct bpf_prog_info, line_info_rec_size),
		      "bpf_prog_info_struct.line_info_rec_size offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO_REC_SIZE */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO_REC_SIZE
	static_assert(sizeof_field(struct bpf_prog_info_struct, jited_line_info_rec_size) == sizeof_field(struct bpf_prog_info, jited_line_info_rec_size),
		      "bpf_prog_info_struct.jited_line_info_rec_size size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, jited_line_info_rec_size) == offsetof(struct bpf_prog_info, jited_line_info_rec_size),
		      "bpf_prog_info_struct.jited_line_info_rec_size offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO_REC_SIZE */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_PROG_TAGS
	static_assert(sizeof_field(struct bpf_prog_info_struct, nr_prog_tags) == sizeof_field(struct bpf_prog_info, nr_prog_tags),
		      "bpf_prog_info_struct.nr_prog_tags size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, nr_prog_tags) == offsetof(struct bpf_prog_info, nr_prog_tags),
		      "bpf_prog_info_struct.nr_prog_tags offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_PROG_TAGS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_PROG_TAGS
	static_assert(sizeof_field(struct bpf_prog_info_struct, prog_tags) == sizeof_field(struct bpf_prog_info, prog_tags),
		      "bpf_prog_info_struct.prog_tags size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, prog_tags) == offsetof(struct bpf_prog_info, prog_tags),
		      "bpf_prog_info_struct.prog_tags offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_PROG_TAGS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_RUN_TIME_NS
	static_assert(sizeof_field(struct bpf_prog_info_struct, run_time_ns) == sizeof_field(struct bpf_prog_info, run_time_ns),
		      "bpf_prog_info_struct.run_time_ns size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, run_time_ns) == offsetof(struct bpf_prog_info, run_time_ns),
		      "bpf_prog_info_struct.run_time_ns offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_RUN_TIME_NS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_RUN_CNT
	static_assert(sizeof_field(struct bpf_prog_info_struct, run_cnt) == sizeof_field(struct bpf_prog_info, run_cnt),
		      "bpf_prog_info_struct.run_cnt size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, run_cnt) == offsetof(struct bpf_prog_info, run_cnt),
		      "bpf_prog_info_struct.run_cnt offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_RUN_CNT */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_RECURSION_MISSES
	static_assert(sizeof_field(struct bpf_prog_info_struct, recursion_misses) == sizeof_field(struct bpf_prog_info, recursion_misses),
		      "bpf_prog_info_struct.recursion_misses size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, recursion_misses) == offsetof(struct bpf_prog_info, recursion_misses),
		      "bpf_prog_info_struct.recursion_misses offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_RECURSION_MISSES */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_VERIFIED_INSNS
	static_assert(sizeof_field(struct bpf_prog_info_struct, verified_insns) == sizeof_field(struct bpf_prog_info, verified_insns),
		      "bpf_prog_info_struct.verified_insns size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, verified_insns) == offsetof(struct bpf_prog_info, verified_insns),
		      "bpf_prog_info_struct.verified_insns offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_VERIFIED_INSNS */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_ATTACH_BTF_OBJ_ID
	static_assert(sizeof_field(struct bpf_prog_info_struct, attach_btf_obj_id) == sizeof_field(struct bpf_prog_info, attach_btf_obj_id),
		      "bpf_prog_info_struct.attach_btf_obj_id size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, attach_btf_obj_id) == offsetof(struct bpf_prog_info, attach_btf_obj_id),
		      "bpf_prog_info_struct.attach_btf_obj_id offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_ATTACH_BTF_OBJ_ID */

# ifdef HAVE_STRUCT_BPF_PROG_INFO_ATTACH_BTF_ID
	static_assert(sizeof_field(struct bpf_prog_info_struct, attach_btf_id) == sizeof_field(struct bpf_prog_info, attach_btf_id),
		      "bpf_prog_info_struct.attach_btf_id size mismatch");
	static_assert(offsetof(struct bpf_prog_info_struct, attach_btf_id) == offsetof(struct bpf_prog_info, attach_btf_id),
		      "bpf_prog_info_struct.attach_btf_id offset mismatch");
# endif /* HAVE_STRUCT_BPF_PROG_INFO_ATTACH_BTF_ID */

static_assert(bpf_prog_info_struct_size == expected_bpf_prog_info_struct_size,
	      "bpf_prog_info_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_BATCH_IN_BATCH
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, in_batch) == sizeof_field(union bpf_attr, batch.in_batch),
		      "BPF_MAP_LOOKUP_BATCH_struct.in_batch size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, in_batch) == offsetof(union bpf_attr, batch.in_batch),
		      "BPF_MAP_LOOKUP_BATCH_struct.in_batch offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BATCH_IN_BATCH */

# ifdef HAVE_UNION_BPF_ATTR_BATCH_OUT_BATCH
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, out_batch) == sizeof_field(union bpf_attr, batch.out_batch),
		      "BPF_MAP_LOOKUP_BATCH_struct.out_batch size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, out_batch) == offsetof(union bpf_attr, batch.out_batch),
		      "BPF_MAP_LOOKUP_BATCH_struct.out_batch offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BATCH_OUT_BATCH */

# ifdef HAVE_UNION_BPF_ATTR_BATCH_KEYS
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, keys) == sizeof_field(union bpf_attr, batch.keys),
		      "BPF_MAP_LOOKUP_BATCH_struct.keys size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, keys) == offsetof(union bpf_attr, batch.keys),
		      "BPF_MAP_LOOKUP_BATCH_struct.keys offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BATCH_KEYS */

# ifdef HAVE_UNION_BPF_ATTR_BATCH_VALUES
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, values) == sizeof_field(union bpf_attr, batch.values),
		      "BPF_MAP_LOOKUP_BATCH_struct.values size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, values) == offsetof(union bpf_attr, batch.values),
		      "BPF_MAP_LOOKUP_BATCH_struct.values offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BATCH_VALUES */

# ifdef HAVE_UNION_BPF_ATTR_BATCH_COUNT
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, count) == sizeof_field(union bpf_attr, batch.count),
		      "BPF_MAP_LOOKUP_BATCH_struct.count size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, count) == offsetof(union bpf_attr, batch.count),
		      "BPF_MAP_LOOKUP_BATCH_struct.count offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BATCH_COUNT */

# ifdef HAVE_UNION_BPF_ATTR_BATCH_MAP_FD
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, map_fd) == sizeof_field(union bpf_attr, batch.map_fd),
		      "BPF_MAP_LOOKUP_BATCH_struct.map_fd size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, map_fd) == offsetof(union bpf_attr, batch.map_fd),
		      "BPF_MAP_LOOKUP_BATCH_struct.map_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BATCH_MAP_FD */

# ifdef HAVE_UNION_BPF_ATTR_BATCH_ELEM_FLAGS
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, elem_flags) == sizeof_field(union bpf_attr, batch.elem_flags),
		      "BPF_MAP_LOOKUP_BATCH_struct.elem_flags size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, elem_flags) == offsetof(union bpf_attr, batch.elem_flags),
		      "BPF_MAP_LOOKUP_BATCH_struct.elem_flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BATCH_ELEM_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_BATCH_FLAGS
	static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, flags) == sizeof_field(union bpf_attr, batch.flags),
		      "BPF_MAP_LOOKUP_BATCH_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, flags) == offsetof(union bpf_attr, batch.flags),
		      "BPF_MAP_LOOKUP_BATCH_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_BATCH_FLAGS */

static_assert(BPF_MAP_LOOKUP_BATCH_struct_size == expected_BPF_MAP_LOOKUP_BATCH_struct_size,
	      "BPF_MAP_LOOKUP_BATCH_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PROG_FD
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, prog_fd) == sizeof_field(union bpf_attr, link_create.prog_fd),
		      "BPF_LINK_CREATE_struct.prog_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, prog_fd) == offsetof(union bpf_attr, link_create.prog_fd),
		      "BPF_LINK_CREATE_struct.prog_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PROG_FD */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_FD
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, target_fd) == sizeof_field(union bpf_attr, link_create.target_fd),
		      "BPF_LINK_CREATE_struct.target_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, target_fd) == offsetof(union bpf_attr, link_create.target_fd),
		      "BPF_LINK_CREATE_struct.target_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_FD */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_IFINDEX
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, target_ifindex) == sizeof_field(union bpf_attr, link_create.target_ifindex),
		      "BPF_LINK_CREATE_struct.target_ifindex size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, target_ifindex) == offsetof(union bpf_attr, link_create.target_ifindex),
		      "BPF_LINK_CREATE_struct.target_ifindex offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_IFINDEX */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ATTACH_TYPE
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, attach_type) == sizeof_field(union bpf_attr, link_create.attach_type),
		      "BPF_LINK_CREATE_struct.attach_type size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, attach_type) == offsetof(union bpf_attr, link_create.attach_type),
		      "BPF_LINK_CREATE_struct.attach_type offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ATTACH_TYPE */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, flags) == sizeof_field(union bpf_attr, link_create.flags),
		      "BPF_LINK_CREATE_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, flags) == offsetof(union bpf_attr, link_create.flags),
		      "BPF_LINK_CREATE_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_BTF_ID
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, target_btf_id) == sizeof_field(union bpf_attr, link_create.target_btf_id),
		      "BPF_LINK_CREATE_struct.target_btf_id size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, target_btf_id) == offsetof(union bpf_attr, link_create.target_btf_id),
		      "BPF_LINK_CREATE_struct.target_btf_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_BTF_ID */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ITER_INFO
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, iter_info) == sizeof_field(union bpf_attr, link_create.iter_info),
		      "BPF_LINK_CREATE_struct.iter_info size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, iter_info) == offsetof(union bpf_attr, link_create.iter_info),
		      "BPF_LINK_CREATE_struct.iter_info offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ITER_INFO */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ITER_INFO_LEN
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, iter_info_len) == sizeof_field(union bpf_attr, link_create.iter_info_len),
		      "BPF_LINK_CREATE_struct.iter_info_len size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, iter_info_len) == offsetof(union bpf_attr, link_create.iter_info_len),
		      "BPF_LINK_CREATE_struct.iter_info_len offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ITER_INFO_LEN */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_BPF_COOKIE
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, bpf_cookie) == sizeof_field(union bpf_attr, link_create.bpf_cookie),
		      "BPF_LINK_CREATE_struct.bpf_cookie size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, bpf_cookie) == offsetof(union bpf_attr, link_create.bpf_cookie),
		      "BPF_LINK_CREATE_struct.bpf_cookie offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_BPF_COOKIE */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PERF_EVENT
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, perf_event) == sizeof_field(union bpf_attr, link_create.perf_event),
		      "BPF_LINK_CREATE_struct.perf_event size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, perf_event) == offsetof(union bpf_attr, link_create.perf_event),
		      "BPF_LINK_CREATE_struct.perf_event offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PERF_EVENT */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, flags) == sizeof_field(union bpf_attr, link_create.flags),
		      "BPF_LINK_CREATE_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, flags) == offsetof(union bpf_attr, link_create.flags),
		      "BPF_LINK_CREATE_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_CNT
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, cnt) == sizeof_field(union bpf_attr, link_create.cnt),
		      "BPF_LINK_CREATE_struct.cnt size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, cnt) == offsetof(union bpf_attr, link_create.cnt),
		      "BPF_LINK_CREATE_struct.cnt offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_CNT */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_SYMS
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, syms) == sizeof_field(union bpf_attr, link_create.syms),
		      "BPF_LINK_CREATE_struct.syms size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, syms) == offsetof(union bpf_attr, link_create.syms),
		      "BPF_LINK_CREATE_struct.syms offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_SYMS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ADDRS
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, addrs) == sizeof_field(union bpf_attr, link_create.addrs),
		      "BPF_LINK_CREATE_struct.addrs size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, addrs) == offsetof(union bpf_attr, link_create.addrs),
		      "BPF_LINK_CREATE_struct.addrs offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ADDRS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_COOKIES
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, cookies) == sizeof_field(union bpf_attr, link_create.cookies),
		      "BPF_LINK_CREATE_struct.cookies size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, cookies) == offsetof(union bpf_attr, link_create.cookies),
		      "BPF_LINK_CREATE_struct.cookies offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_COOKIES */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_KPROBE_MULTI
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, kprobe_multi) == sizeof_field(union bpf_attr, link_create.kprobe_multi),
		      "BPF_LINK_CREATE_struct.kprobe_multi size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, kprobe_multi) == offsetof(union bpf_attr, link_create.kprobe_multi),
		      "BPF_LINK_CREATE_struct.kprobe_multi offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_KPROBE_MULTI */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_BTF_ID
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, target_btf_id) == sizeof_field(union bpf_attr, link_create.target_btf_id),
		      "BPF_LINK_CREATE_struct.target_btf_id size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, target_btf_id) == offsetof(union bpf_attr, link_create.target_btf_id),
		      "BPF_LINK_CREATE_struct.target_btf_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_BTF_ID */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PF
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, pf) == sizeof_field(union bpf_attr, link_create.pf),
		      "BPF_LINK_CREATE_struct.pf size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, pf) == offsetof(union bpf_attr, link_create.pf),
		      "BPF_LINK_CREATE_struct.pf offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PF */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_HOOKNUM
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, hooknum) == sizeof_field(union bpf_attr, link_create.hooknum),
		      "BPF_LINK_CREATE_struct.hooknum size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, hooknum) == offsetof(union bpf_attr, link_create.hooknum),
		      "BPF_LINK_CREATE_struct.hooknum offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_HOOKNUM */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PRIORITY
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, priority) == sizeof_field(union bpf_attr, link_create.priority),
		      "BPF_LINK_CREATE_struct.priority size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, priority) == offsetof(union bpf_attr, link_create.priority),
		      "BPF_LINK_CREATE_struct.priority offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PRIORITY */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, flags) == sizeof_field(union bpf_attr, link_create.flags),
		      "BPF_LINK_CREATE_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, flags) == offsetof(union bpf_attr, link_create.flags),
		      "BPF_LINK_CREATE_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_NETFILTER
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, netfilter) == sizeof_field(union bpf_attr, link_create.netfilter),
		      "BPF_LINK_CREATE_struct.netfilter size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, netfilter) == offsetof(union bpf_attr, link_create.netfilter),
		      "BPF_LINK_CREATE_struct.netfilter offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_NETFILTER */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_FD
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, relative_fd) == sizeof_field(union bpf_attr, link_create.relative_fd),
		      "BPF_LINK_CREATE_struct.relative_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, relative_fd) == offsetof(union bpf_attr, link_create.relative_fd),
		      "BPF_LINK_CREATE_struct.relative_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_FD */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_ID
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, relative_id) == sizeof_field(union bpf_attr, link_create.relative_id),
		      "BPF_LINK_CREATE_struct.relative_id size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, relative_id) == offsetof(union bpf_attr, link_create.relative_id),
		      "BPF_LINK_CREATE_struct.relative_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_ID */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PATH
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, path) == sizeof_field(union bpf_attr, link_create.path),
		      "BPF_LINK_CREATE_struct.path size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, path) == offsetof(union bpf_attr, link_create.path),
		      "BPF_LINK_CREATE_struct.path offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PATH */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_OFFSETS
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, offsets) == sizeof_field(union bpf_attr, link_create.offsets),
		      "BPF_LINK_CREATE_struct.offsets size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, offsets) == offsetof(union bpf_attr, link_create.offsets),
		      "BPF_LINK_CREATE_struct.offsets offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_OFFSETS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_REF_CTR_OFFSETS
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, ref_ctr_offsets) == sizeof_field(union bpf_attr, link_create.ref_ctr_offsets),
		      "BPF_LINK_CREATE_struct.ref_ctr_offsets size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, ref_ctr_offsets) == offsetof(union bpf_attr, link_create.ref_ctr_offsets),
		      "BPF_LINK_CREATE_struct.ref_ctr_offsets offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_REF_CTR_OFFSETS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_COOKIES
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, cookies) == sizeof_field(union bpf_attr, link_create.cookies),
		      "BPF_LINK_CREATE_struct.cookies size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, cookies) == offsetof(union bpf_attr, link_create.cookies),
		      "BPF_LINK_CREATE_struct.cookies offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_COOKIES */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_CNT
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, cnt) == sizeof_field(union bpf_attr, link_create.cnt),
		      "BPF_LINK_CREATE_struct.cnt size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, cnt) == offsetof(union bpf_attr, link_create.cnt),
		      "BPF_LINK_CREATE_struct.cnt offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_CNT */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, flags) == sizeof_field(union bpf_attr, link_create.flags),
		      "BPF_LINK_CREATE_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, flags) == offsetof(union bpf_attr, link_create.flags),
		      "BPF_LINK_CREATE_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PID
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, pid) == sizeof_field(union bpf_attr, link_create.pid),
		      "BPF_LINK_CREATE_struct.pid size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, pid) == offsetof(union bpf_attr, link_create.pid),
		      "BPF_LINK_CREATE_struct.pid offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PID */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_UPROBE_MULTI
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, uprobe_multi) == sizeof_field(union bpf_attr, link_create.uprobe_multi),
		      "BPF_LINK_CREATE_struct.uprobe_multi size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, uprobe_multi) == offsetof(union bpf_attr, link_create.uprobe_multi),
		      "BPF_LINK_CREATE_struct.uprobe_multi offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_UPROBE_MULTI */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_FD
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, relative_fd) == sizeof_field(union bpf_attr, link_create.relative_fd),
		      "BPF_LINK_CREATE_struct.relative_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, relative_fd) == offsetof(union bpf_attr, link_create.relative_fd),
		      "BPF_LINK_CREATE_struct.relative_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_FD */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_ID
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, relative_id) == sizeof_field(union bpf_attr, link_create.relative_id),
		      "BPF_LINK_CREATE_struct.relative_id size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, relative_id) == offsetof(union bpf_attr, link_create.relative_id),
		      "BPF_LINK_CREATE_struct.relative_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_ID */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_EXPECTED_REVISION
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, expected_revision) == sizeof_field(union bpf_attr, link_create.expected_revision),
		      "BPF_LINK_CREATE_struct.expected_revision size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, expected_revision) == offsetof(union bpf_attr, link_create.expected_revision),
		      "BPF_LINK_CREATE_struct.expected_revision offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_EXPECTED_REVISION */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_FD
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, relative_fd) == sizeof_field(union bpf_attr, link_create.relative_fd),
		      "BPF_LINK_CREATE_struct.relative_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, relative_fd) == offsetof(union bpf_attr, link_create.relative_fd),
		      "BPF_LINK_CREATE_struct.relative_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_FD */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_ID
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, relative_id) == sizeof_field(union bpf_attr, link_create.relative_id),
		      "BPF_LINK_CREATE_struct.relative_id size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, relative_id) == offsetof(union bpf_attr, link_create.relative_id),
		      "BPF_LINK_CREATE_struct.relative_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_RELATIVE_ID */

# ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_EXPECTED_REVISION
	static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, expected_revision) == sizeof_field(union bpf_attr, link_create.expected_revision),
		      "BPF_LINK_CREATE_struct.expected_revision size mismatch");
	static_assert(offsetof(struct BPF_LINK_CREATE_struct, expected_revision) == offsetof(union bpf_attr, link_create.expected_revision),
		      "BPF_LINK_CREATE_struct.expected_revision offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_EXPECTED_REVISION */

static_assert(BPF_LINK_CREATE_struct_size == expected_BPF_LINK_CREATE_struct_size,
	      "BPF_LINK_CREATE_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_LINK_FD
	static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, link_fd) == sizeof_field(union bpf_attr, link_update.link_fd),
		      "BPF_LINK_UPDATE_struct.link_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_UPDATE_struct, link_fd) == offsetof(union bpf_attr, link_update.link_fd),
		      "BPF_LINK_UPDATE_struct.link_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_LINK_FD */

# ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_NEW_PROG_FD
	static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, new_prog_fd) == sizeof_field(union bpf_attr, link_update.new_prog_fd),
		      "BPF_LINK_UPDATE_struct.new_prog_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_UPDATE_struct, new_prog_fd) == offsetof(union bpf_attr, link_update.new_prog_fd),
		      "BPF_LINK_UPDATE_struct.new_prog_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_NEW_PROG_FD */

# ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_FLAGS
	static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, flags) == sizeof_field(union bpf_attr, link_update.flags),
		      "BPF_LINK_UPDATE_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_LINK_UPDATE_struct, flags) == offsetof(union bpf_attr, link_update.flags),
		      "BPF_LINK_UPDATE_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_OLD_PROG_FD
	static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, old_prog_fd) == sizeof_field(union bpf_attr, link_update.old_prog_fd),
		      "BPF_LINK_UPDATE_struct.old_prog_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_UPDATE_struct, old_prog_fd) == offsetof(union bpf_attr, link_update.old_prog_fd),
		      "BPF_LINK_UPDATE_struct.old_prog_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_OLD_PROG_FD */

static_assert(BPF_LINK_UPDATE_struct_size == expected_BPF_LINK_UPDATE_struct_size,
	      "BPF_LINK_UPDATE_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_LINK_ID
	static_assert(sizeof_field(struct BPF_LINK_GET_FD_BY_ID_struct, link_id) == sizeof_field(union bpf_attr, link_id),
		      "BPF_LINK_GET_FD_BY_ID_struct.link_id size mismatch");
	static_assert(offsetof(struct BPF_LINK_GET_FD_BY_ID_struct, link_id) == offsetof(union bpf_attr, link_id),
		      "BPF_LINK_GET_FD_BY_ID_struct.link_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_ID */

static_assert(BPF_LINK_GET_FD_BY_ID_struct_size == expected_BPF_LINK_GET_FD_BY_ID_struct_size,
	      "BPF_LINK_GET_FD_BY_ID_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_ENABLE_STATS_TYPE
	static_assert(sizeof_field(struct BPF_ENABLE_STATS_struct, type) == sizeof_field(union bpf_attr, enable_stats.type),
		      "BPF_ENABLE_STATS_struct.type size mismatch");
	static_assert(offsetof(struct BPF_ENABLE_STATS_struct, type) == offsetof(union bpf_attr, enable_stats.type),
		      "BPF_ENABLE_STATS_struct.type offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_ENABLE_STATS_TYPE */

static_assert(BPF_ENABLE_STATS_struct_size == expected_BPF_ENABLE_STATS_struct_size,
	      "BPF_ENABLE_STATS_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_ITER_CREATE_LINK_FD
	static_assert(sizeof_field(struct BPF_ITER_CREATE_struct, link_fd) == sizeof_field(union bpf_attr, iter_create.link_fd),
		      "BPF_ITER_CREATE_struct.link_fd size mismatch");
	static_assert(offsetof(struct BPF_ITER_CREATE_struct, link_fd) == offsetof(union bpf_attr, iter_create.link_fd),
		      "BPF_ITER_CREATE_struct.link_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_ITER_CREATE_LINK_FD */

# ifdef HAVE_UNION_BPF_ATTR_ITER_CREATE_FLAGS
	static_assert(sizeof_field(struct BPF_ITER_CREATE_struct, flags) == sizeof_field(union bpf_attr, iter_create.flags),
		      "BPF_ITER_CREATE_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_ITER_CREATE_struct, flags) == offsetof(union bpf_attr, iter_create.flags),
		      "BPF_ITER_CREATE_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_ITER_CREATE_FLAGS */

static_assert(BPF_ITER_CREATE_struct_size == expected_BPF_ITER_CREATE_struct_size,
	      "BPF_ITER_CREATE_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_LINK_DETACH_LINK_FD
	static_assert(sizeof_field(struct BPF_LINK_DETACH_struct, link_fd) == sizeof_field(union bpf_attr, link_detach.link_fd),
		      "BPF_LINK_DETACH_struct.link_fd size mismatch");
	static_assert(offsetof(struct BPF_LINK_DETACH_struct, link_fd) == offsetof(union bpf_attr, link_detach.link_fd),
		      "BPF_LINK_DETACH_struct.link_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_LINK_DETACH_LINK_FD */

static_assert(BPF_LINK_DETACH_struct_size == expected_BPF_LINK_DETACH_struct_size,
	      "BPF_LINK_DETACH_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_PROG_FD
	static_assert(sizeof_field(struct BPF_PROG_BIND_MAP_struct, prog_fd) == sizeof_field(union bpf_attr, prog_bind_map.prog_fd),
		      "BPF_PROG_BIND_MAP_struct.prog_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_BIND_MAP_struct, prog_fd) == offsetof(union bpf_attr, prog_bind_map.prog_fd),
		      "BPF_PROG_BIND_MAP_struct.prog_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_PROG_FD */

# ifdef HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_MAP_FD
	static_assert(sizeof_field(struct BPF_PROG_BIND_MAP_struct, map_fd) == sizeof_field(union bpf_attr, prog_bind_map.map_fd),
		      "BPF_PROG_BIND_MAP_struct.map_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_BIND_MAP_struct, map_fd) == offsetof(union bpf_attr, prog_bind_map.map_fd),
		      "BPF_PROG_BIND_MAP_struct.map_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_MAP_FD */

# ifdef HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_FLAGS
	static_assert(sizeof_field(struct BPF_PROG_BIND_MAP_struct, flags) == sizeof_field(union bpf_attr, prog_bind_map.flags),
		      "BPF_PROG_BIND_MAP_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_PROG_BIND_MAP_struct, flags) == offsetof(union bpf_attr, prog_bind_map.flags),
		      "BPF_PROG_BIND_MAP_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_FLAGS */

static_assert(BPF_PROG_BIND_MAP_struct_size == expected_BPF_PROG_BIND_MAP_struct_size,
	      "BPF_PROG_BIND_MAP_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_TOKEN_CREATE_FLAGS
	static_assert(sizeof_field(struct BPF_TOKEN_CREATE_struct, flags) == sizeof_field(union bpf_attr, token_create.flags),
		      "BPF_TOKEN_CREATE_struct.flags size mismatch");
	static_assert(offsetof(struct BPF_TOKEN_CREATE_struct, flags) == offsetof(union bpf_attr, token_create.flags),
		      "BPF_TOKEN_CREATE_struct.flags offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TOKEN_CREATE_FLAGS */

# ifdef HAVE_UNION_BPF_ATTR_TOKEN_CREATE_BPFFS_FD
	static_assert(sizeof_field(struct BPF_TOKEN_CREATE_struct, bpffs_fd) == sizeof_field(union bpf_attr, token_create.bpffs_fd),
		      "BPF_TOKEN_CREATE_struct.bpffs_fd size mismatch");
	static_assert(offsetof(struct BPF_TOKEN_CREATE_struct, bpffs_fd) == offsetof(union bpf_attr, token_create.bpffs_fd),
		      "BPF_TOKEN_CREATE_struct.bpffs_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_TOKEN_CREATE_BPFFS_FD */

static_assert(BPF_TOKEN_CREATE_struct_size == expected_BPF_TOKEN_CREATE_struct_size,
	      "BPF_TOKEN_CREATE_struct_size mismatch");

# ifdef HAVE_UNION_BPF_ATTR_PROG_STREAM_READ_STREAM_BUF
	static_assert(sizeof_field(struct BPF_PROG_STREAM_READ_BY_FD_struct, stream_buf) == sizeof_field(union bpf_attr, prog_stream_read.stream_buf),
		      "BPF_PROG_STREAM_READ_BY_FD_struct.stream_buf size mismatch");
	static_assert(offsetof(struct BPF_PROG_STREAM_READ_BY_FD_struct, stream_buf) == offsetof(union bpf_attr, prog_stream_read.stream_buf),
		      "BPF_PROG_STREAM_READ_BY_FD_struct.stream_buf offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_STREAM_READ_STREAM_BUF */

# ifdef HAVE_UNION_BPF_ATTR_PROG_STREAM_READ_STREAM_BUF_LEN
	static_assert(sizeof_field(struct BPF_PROG_STREAM_READ_BY_FD_struct, stream_buf_len) == sizeof_field(union bpf_attr, prog_stream_read.stream_buf_len),
		      "BPF_PROG_STREAM_READ_BY_FD_struct.stream_buf_len size mismatch");
	static_assert(offsetof(struct BPF_PROG_STREAM_READ_BY_FD_struct, stream_buf_len) == offsetof(union bpf_attr, prog_stream_read.stream_buf_len),
		      "BPF_PROG_STREAM_READ_BY_FD_struct.stream_buf_len offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_STREAM_READ_STREAM_BUF_LEN */

# ifdef HAVE_UNION_BPF_ATTR_PROG_STREAM_READ_STREAM_ID
	static_assert(sizeof_field(struct BPF_PROG_STREAM_READ_BY_FD_struct, stream_id) == sizeof_field(union bpf_attr, prog_stream_read.stream_id),
		      "BPF_PROG_STREAM_READ_BY_FD_struct.stream_id size mismatch");
	static_assert(offsetof(struct BPF_PROG_STREAM_READ_BY_FD_struct, stream_id) == offsetof(union bpf_attr, prog_stream_read.stream_id),
		      "BPF_PROG_STREAM_READ_BY_FD_struct.stream_id offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_STREAM_READ_STREAM_ID */

# ifdef HAVE_UNION_BPF_ATTR_PROG_STREAM_READ_PROG_FD
	static_assert(sizeof_field(struct BPF_PROG_STREAM_READ_BY_FD_struct, prog_fd) == sizeof_field(union bpf_attr, prog_stream_read.prog_fd),
		      "BPF_PROG_STREAM_READ_BY_FD_struct.prog_fd size mismatch");
	static_assert(offsetof(struct BPF_PROG_STREAM_READ_BY_FD_struct, prog_fd) == offsetof(union bpf_attr, prog_stream_read.prog_fd),
		      "BPF_PROG_STREAM_READ_BY_FD_struct.prog_fd offset mismatch");
# endif /* HAVE_UNION_BPF_ATTR_PROG_STREAM_READ_PROG_FD */

static_assert(BPF_PROG_STREAM_READ_BY_FD_struct_size == expected_BPF_PROG_STREAM_READ_BY_FD_struct_size,
	      "BPF_PROG_STREAM_READ_BY_FD_struct_size mismatch");

#endif /* HAVE_LINUX_BPF_H */
