/* Generated by `lib9p/core.gen lib9p/idl/0000-uninitialized.9p lib9p/idl/2002-9P2000.9p lib9p/idl/2003-9P2000.p9p.9p lib9p/idl/2005-9P2000.u.9p lib9p/idl/2010-9P2000.L.9p lib9p/idl/2012-9P2000.e.9p`.  DO NOT EDIT!  */

#include <stddef.h>   /* for size_t */
#include <inttypes.h> /* for PRI* macros */
#include <string.h>   /* for memset() */

#include <libmisc/assert.h>
#include <libmisc/endian.h>

#include <lib9p/core.h>

#include "core_tables.h"
#include "core_utf8.h"

/* utilities ******************************************************************/
#if CONFIG_9P_ENABLE_9P2000
	#define _is_ver_9P2000(v) (v == LIB9P_VER_9P2000)
#else
	#define _is_ver_9P2000(v) false
#endif
#if CONFIG_9P_ENABLE_9P2000_L
	#define _is_ver_9P2000_L(v) (v == LIB9P_VER_9P2000_L)
#else
	#define _is_ver_9P2000_L(v) false
#endif
#if CONFIG_9P_ENABLE_9P2000_e
	#define _is_ver_9P2000_e(v) (v == LIB9P_VER_9P2000_e)
#else
	#define _is_ver_9P2000_e(v) false
#endif
#if CONFIG_9P_ENABLE_9P2000_p9p
	#define _is_ver_9P2000_p9p(v) (v == LIB9P_VER_9P2000_p9p)
#else
	#define _is_ver_9P2000_p9p(v) false
#endif
#if CONFIG_9P_ENABLE_9P2000_u
	#define _is_ver_9P2000_u(v) (v == LIB9P_VER_9P2000_u)
#else
	#define _is_ver_9P2000_u(v) false
#endif
#if CONFIG_9P_ENABLE_uninitialized
	#define _is_ver_uninitialized(v) (v == LIB9P_VER_uninitialized)
#else
	#define _is_ver_uninitialized(v) false
#endif

/**
 * is_ver(ctx, ver) is essentially `(ctx->version == LIB9P_VER_##ver)`, but
 * compiles correctly (to `false`) even if `LIB9P_VER_##ver` isn't defined
 * (because `!CONFIG_9P_ENABLE_##ver`).  This is useful when `||`ing
 * several version checks together.
 */
#define is_ver(ctx, ver) _is_ver_##ver((ctx)->version)

/* bitmasks *******************************************************************/

#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static const lib9p_dm_t dm_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]        = 0b11111100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]      = 0b11111100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p]    = 0b11111100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]      = 0b11111100101111000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = 0b11111100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static const lib9p_qt_t qt_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]        = 0b11111100,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L]      = 0b11111100,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]      = 0b11111100,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p]    = 0b11111100,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]      = 0b11111110,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = 0b11111100,
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static const lib9p_o_t o_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]        = 0b01010011,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L]      = 0b00000000,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]      = 0b01010011,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p]    = 0b01010011,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]      = 0b01010011,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = 0b00000000,
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_L
static const lib9p_lo_t lo_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]        = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000 */
	[LIB9P_VER_9P2000_L]      = 0b00000000000111111111111111000011,
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p]    = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

static const lib9p_mode_t mode_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]        = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000 */
	[LIB9P_VER_9P2000_L]      = 0b00000000000000001111111111111111,
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p]    = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

static const lib9p_getattr_t getattr_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]        = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000 */
	[LIB9P_VER_9P2000_L]      = 0b0000000000000000000000000000000000000000000000000011111111111111,
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]      = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p]    = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]      = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

static const lib9p_setattr_t setattr_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]        = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000 */
	[LIB9P_VER_9P2000_L]      = 0b00000000000000000000000111111111,
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p]    = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

static const lib9p_lock_flags_t lock_flags_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]        = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000 */
	[LIB9P_VER_9P2000_L]      = 0b00000000000000000000000000000011,
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p]    = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]      = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_uninitialized */
};
#endif /* CONFIG_9P_ENABLE_9P2000_L */

/* validate_* *****************************************************************/

#define VALIDATE_NET_BYTES(n)                                                                       \
	if (__builtin_add_overflow(net_offset, n, &net_offset))                                     \
		/* If needed-net-size overflowed uint32_t, then                                     \
		 * there's no way that actual-net-size will live up to                              \
		 * that.  */                                                                        \
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "message is too short for content"); \
	if (net_offset > net_size)                                                                  \
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "message is too short for content (", net_offset, " > ", net_size, ")");
#define VALIDATE_NET_UTF8(n)                                                                              \
	{                                                                                                 \
		size_t len = n;                                                                           \
		VALIDATE_NET_BYTES(len);                                                                  \
		if (!is_valid_utf8_without_nul(&net_bytes[net_offset-len], len))                          \
			return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "message contains invalid UTF-8"); \
	}
#define RESERVE_HOST_BYTES(n)                                           \
	if (__builtin_add_overflow(host_size, n, &host_size))           \
		/* If needed-host-size overflowed ssize_t, then there's \
		 * no way that actual-net-size will live up to          \
		 * that.  */                                            \
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "message is too short for content");
#define GET_U8LE(off)  (net_bytes[off])
#define GET_U16LE(off) uint16le_decode(&net_bytes[off])
#define GET_U32LE(off) uint32le_decode(&net_bytes[off])
#define GET_U64LE(off) uint64le_decode(&net_bytes[off])
#define LAST_U8LE()  GET_U8LE(net_offset-1)
#define LAST_U16LE() GET_U16LE(net_offset-2)
#define LAST_U32LE() GET_U32LE(net_offset-4)
#define LAST_U64LE() GET_U64LE(net_offset-8)

#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static ssize_t validate_stat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes, uint32_t *ret_net_size) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_stat);
	uint32_t offsetof__stat_size = net_offset + 0;
	uint32_t offsetof_fstype = net_offset + 2;
	uint32_t offsetof_qid_type = net_offset + 8;
	VALIDATE_NET_BYTES(21);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_mode = net_offset + 0;
	VALIDATE_NET_BYTES(22);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		VALIDATE_NET_BYTES(2);
		VALIDATE_NET_UTF8(LAST_U16LE());
		VALIDATE_NET_BYTES(12);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof__stat_size) != offsetof_end - offsetof_fstype)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "stat->_stat_size value is wrong: actual:", (base10, GET_U32LE(offsetof__stat_size)), " != correct:", (base10, offsetof_end - offsetof_fstype));
	if (GET_U32LE(offsetof_mode) & ~dm_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in dm bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_mode) & ~dm_masks[ctx->version]));
	if (ret_net_size)
		*ret_net_size = net_offset;
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
static ssize_t validate_Tversion(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tversion);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tversion->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 100)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tversion->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 100));
	return (ssize_t)host_size;
}

static ssize_t validate_Rversion(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rversion);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rversion->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 101)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rversion->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 101));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static ssize_t validate_Tauth(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tauth);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
		VALIDATE_NET_BYTES(4);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tauth->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 102)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tauth->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 102));
	return (ssize_t)host_size;
}

static ssize_t validate_Rauth(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rauth);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_aqid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_aqid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_aqid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rauth->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 103)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rauth->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 103));
	return (ssize_t)host_size;
}

static ssize_t validate_Tattach(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tattach);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(17);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
		VALIDATE_NET_BYTES(4);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tattach->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 104)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tattach->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 104));
	return (ssize_t)host_size;
}

static ssize_t validate_Rattach(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rattach);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rattach->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 105)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rattach->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 105));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
static ssize_t validate_Rerror(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rerror);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(9);
	VALIDATE_NET_UTF8(LAST_U16LE());
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		VALIDATE_NET_BYTES(4);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rerror->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 107)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rerror->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 107));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static ssize_t validate_Tflush(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tflush);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 9;
	VALIDATE_NET_BYTES(9);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tflush->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 108)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tflush->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 108));
	return (ssize_t)host_size;
}

static ssize_t validate_Rflush(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rflush);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rflush->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 109)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rflush->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 109));
	return (ssize_t)host_size;
}

static ssize_t validate_Twalk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Twalk);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_nwname = net_offset + 15;
	VALIDATE_NET_BYTES(17);
	for (uint16_t i = 0, cnt = LAST_U16LE(); i < cnt; i++) {
		RESERVE_HOST_BYTES(sizeof(struct lib9p_s));
		VALIDATE_NET_BYTES(2);
		VALIDATE_NET_UTF8(LAST_U16LE());
	}
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twalk->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 110)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twalk->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 110));
	if (GET_U16LE(offsetof_nwname) > 16)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twalk->nwname value is too large: ", (base10, GET_U16LE(offsetof_nwname)), " > ", (base10, 16));
	return (ssize_t)host_size;
}

static ssize_t validate_Rwalk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rwalk);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_nwqid = net_offset + 7;
	VALIDATE_NET_BYTES(9);
	for (uint16_t i = 0, cnt = LAST_U16LE(); i < cnt; i++) {
		RESERVE_HOST_BYTES(sizeof(struct lib9p_qid));
		uint32_t offsetof_wqid_type = net_offset + 0;
		VALIDATE_NET_BYTES(13);
		if (GET_U8LE(offsetof_wqid_type) & ~qt_masks[ctx->version])
			return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
				(base16_u8_, GET_U8LE(offsetof_wqid_type) & ~qt_masks[ctx->version]));
	}
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwalk->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 111)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwalk->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 111));
	if (GET_U16LE(offsetof_nwqid) > 16)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwalk->nwqid value is too large: ", (base10, GET_U16LE(offsetof_nwqid)), " > ", (base10, 16));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static ssize_t validate_Topen(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Topen);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_mode = net_offset + 11;
	uint32_t offsetof_end = net_offset + 12;
	VALIDATE_NET_BYTES(12);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Topen->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 112)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Topen->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 112));
	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in o bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_mode) & ~o_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Ropen(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Ropen);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 4;
	VALIDATE_NET_BYTES(4);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Ropen->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 113)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Ropen->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 113));
	return (ssize_t)host_size;
}

static ssize_t validate_Tcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tcreate);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_perm = net_offset + 0;
	uint32_t offsetof_mode = net_offset + 4;
	uint32_t offsetof_end = net_offset + 5;
	VALIDATE_NET_BYTES(5);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tcreate->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 114)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tcreate->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 114));
	if (GET_U32LE(offsetof_perm) & ~dm_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in dm bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_perm) & ~dm_masks[ctx->version]));
	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in o bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_mode) & ~o_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Rcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rcreate);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 4;
	VALIDATE_NET_BYTES(4);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rcreate->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 115)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rcreate->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 115));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static ssize_t validate_Tread(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tread);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_offset = net_offset + 11;
	uint32_t offsetof_count = net_offset + 19;
	uint32_t offsetof_end = net_offset + 23;
	VALIDATE_NET_BYTES(23);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tread->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 116)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tread->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 116));
	if (GET_U64LE(offsetof_offset) > INT64_MAX)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tread->offset value is too large: ", (base10, GET_U64LE(offsetof_offset)), " > ", (base10, INT64_MAX));
	if (GET_U32LE(offsetof_count) > INT32_MAX)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tread->count value is too large: ", (base10, GET_U32LE(offsetof_count)), " > ", (base10, INT32_MAX));
	return (ssize_t)host_size;
}

static ssize_t validate_Rread(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rread);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_count = net_offset + 7;
	VALIDATE_NET_BYTES(11);
	VALIDATE_NET_BYTES(LAST_U32LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rread->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 117)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rread->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 117));
	if (GET_U32LE(offsetof_count) > INT32_MAX)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rread->count value is too large: ", (base10, GET_U32LE(offsetof_count)), " > ", (base10, INT32_MAX));
	return (ssize_t)host_size;
}

static ssize_t validate_Twrite(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Twrite);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_offset = net_offset + 11;
	uint32_t offsetof_count = net_offset + 19;
	VALIDATE_NET_BYTES(23);
	VALIDATE_NET_BYTES(LAST_U32LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twrite->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 118)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twrite->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 118));
	if (GET_U64LE(offsetof_offset) > INT64_MAX)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twrite->offset value is too large: ", (base10, GET_U64LE(offsetof_offset)), " > ", (base10, INT64_MAX));
	if (GET_U32LE(offsetof_count) > INT32_MAX)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twrite->count value is too large: ", (base10, GET_U32LE(offsetof_count)), " > ", (base10, INT32_MAX));
	return (ssize_t)host_size;
}

static ssize_t validate_Rwrite(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rwrite);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_count = net_offset + 7;
	uint32_t offsetof_end = net_offset + 11;
	VALIDATE_NET_BYTES(11);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwrite->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 119)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwrite->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 119));
	if (GET_U32LE(offsetof_count) > INT32_MAX)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwrite->count value is too large: ", (base10, GET_U32LE(offsetof_count)), " > ", (base10, INT32_MAX));
	return (ssize_t)host_size;
}

static ssize_t validate_Tclunk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tclunk);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 11;
	VALIDATE_NET_BYTES(11);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tclunk->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 120)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tclunk->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 120));
	return (ssize_t)host_size;
}

static ssize_t validate_Rclunk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rclunk);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rclunk->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 121)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rclunk->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 121));
	return (ssize_t)host_size;
}

static ssize_t validate_Tremove(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tremove);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 11;
	VALIDATE_NET_BYTES(11);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tremove->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 122)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tremove->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 122));
	return (ssize_t)host_size;
}

static ssize_t validate_Rremove(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rremove);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rremove->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 123)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rremove->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 123));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static ssize_t validate_Tstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tstat);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 11;
	VALIDATE_NET_BYTES(11);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tstat->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 124)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tstat->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 124));
	return (ssize_t)host_size;
}

static ssize_t validate_Rstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rstat);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_nstat = net_offset + 7;
	uint32_t offsetof_stat = net_offset + 9;
	uint32_t offsetof_stat__stat_size = net_offset + 9;
	uint32_t offsetof_stat_fstype = net_offset + 11;
	uint32_t offsetof_stat_qid_type = net_offset + 17;
	VALIDATE_NET_BYTES(30);
	if (GET_U8LE(offsetof_stat_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_stat_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_stat_mode = net_offset + 0;
	VALIDATE_NET_BYTES(22);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		VALIDATE_NET_BYTES(2);
		VALIDATE_NET_UTF8(LAST_U16LE());
		VALIDATE_NET_BYTES(12);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_stat_end = net_offset + 0;
	if (GET_U32LE(offsetof_stat__stat_size) != offsetof_stat_end - offsetof_stat_fstype)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstat->stat._stat_size value is wrong: actual:", (base10, GET_U32LE(offsetof_stat__stat_size)), " != correct:", (base10, offsetof_stat_end - offsetof_stat_fstype));
	if (GET_U32LE(offsetof_stat_mode) & ~dm_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in dm bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_stat_mode) & ~dm_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstat->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 125)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstat->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 125));
	if (GET_U32LE(offsetof_nstat) != offsetof_end - offsetof_stat)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstat->nstat value is wrong: actual:", (base10, GET_U32LE(offsetof_nstat)), " != correct:", (base10, offsetof_end - offsetof_stat));
	return (ssize_t)host_size;
}

static ssize_t validate_Twstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Twstat);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_nstat = net_offset + 11;
	uint32_t offsetof_stat = net_offset + 13;
	uint32_t offsetof_stat__stat_size = net_offset + 13;
	uint32_t offsetof_stat_fstype = net_offset + 15;
	uint32_t offsetof_stat_qid_type = net_offset + 21;
	VALIDATE_NET_BYTES(34);
	if (GET_U8LE(offsetof_stat_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_stat_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_stat_mode = net_offset + 0;
	VALIDATE_NET_BYTES(22);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		VALIDATE_NET_BYTES(2);
		VALIDATE_NET_UTF8(LAST_U16LE());
		VALIDATE_NET_BYTES(12);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_stat_end = net_offset + 0;
	if (GET_U32LE(offsetof_stat__stat_size) != offsetof_stat_end - offsetof_stat_fstype)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twstat->stat._stat_size value is wrong: actual:", (base10, GET_U32LE(offsetof_stat__stat_size)), " != correct:", (base10, offsetof_stat_end - offsetof_stat_fstype));
	if (GET_U32LE(offsetof_stat_mode) & ~dm_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in dm bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_stat_mode) & ~dm_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twstat->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 126)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twstat->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 126));
	if (GET_U32LE(offsetof_nstat) != offsetof_end - offsetof_stat)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Twstat->nstat value is wrong: actual:", (base10, GET_U32LE(offsetof_nstat)), " != correct:", (base10, offsetof_end - offsetof_stat));
	return (ssize_t)host_size;
}

static ssize_t validate_Rwstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rwstat);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwstat->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 127)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwstat->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 127));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_p9p
static ssize_t validate_Topenfd(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Topenfd);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_mode = net_offset + 11;
	uint32_t offsetof_end = net_offset + 12;
	VALIDATE_NET_BYTES(12);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Topenfd->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 98)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Topenfd->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 98));
	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in o bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_mode) & ~o_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Ropenfd(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Ropenfd);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 8;
	VALIDATE_NET_BYTES(8);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Ropenfd->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 99)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Ropenfd->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 99));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_L
static ssize_t validate_Rlerror(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rlerror);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 11;
	VALIDATE_NET_BYTES(11);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlerror->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 7)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlerror->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 7));
	return (ssize_t)host_size;
}

static ssize_t validate_Tstatfs(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tstatfs);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 11;
	VALIDATE_NET_BYTES(11);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tstatfs->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 8)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tstatfs->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 8));
	return (ssize_t)host_size;
}

static ssize_t validate_Rstatfs(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rstatfs);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 67;
	VALIDATE_NET_BYTES(67);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstatfs->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 9)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstatfs->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 9));
	return (ssize_t)host_size;
}

static ssize_t validate_Tlopen(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tlopen);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_flags = net_offset + 11;
	uint32_t offsetof_end = net_offset + 15;
	VALIDATE_NET_BYTES(15);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlopen->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 12)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlopen->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 12));
	if (GET_U32LE(offsetof_flags) & ~lo_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in lo bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_flags) & ~lo_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Rlopen(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rlopen);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 4;
	VALIDATE_NET_BYTES(4);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlopen->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 13)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlopen->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 13));
	return (ssize_t)host_size;
}

static ssize_t validate_Tlcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tlcreate);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_flags = net_offset + 0;
	uint32_t offsetof_mode = net_offset + 4;
	uint32_t offsetof_end = net_offset + 12;
	VALIDATE_NET_BYTES(12);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlcreate->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 14)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlcreate->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 14));
	if (GET_U32LE(offsetof_flags) & ~lo_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in lo bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_flags) & ~lo_masks[ctx->version]));
	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Rlcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rlcreate);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 4;
	VALIDATE_NET_BYTES(4);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlcreate->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 15)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlcreate->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 15));
	return (ssize_t)host_size;
}

static ssize_t validate_Tsymlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tsymlink);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(2);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 4;
	VALIDATE_NET_BYTES(4);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsymlink->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 16)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsymlink->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 16));
	return (ssize_t)host_size;
}

static ssize_t validate_Rsymlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rsymlink);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsymlink->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 17)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsymlink->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 17));
	return (ssize_t)host_size;
}

static ssize_t validate_Tmknod(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tmknod);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_mode = net_offset + 0;
	uint32_t offsetof_end = net_offset + 16;
	VALIDATE_NET_BYTES(16);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tmknod->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 18)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tmknod->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 18));
	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Rmknod(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rmknod);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rmknod->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 19)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rmknod->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 19));
	return (ssize_t)host_size;
}

static ssize_t validate_Trename(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Trename);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(17);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Trename->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 20)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Trename->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 20));
	return (ssize_t)host_size;
}

static ssize_t validate_Rrename(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rrename);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rrename->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 21)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rrename->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 21));
	return (ssize_t)host_size;
}

static ssize_t validate_Treadlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Treadlink);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 11;
	VALIDATE_NET_BYTES(11);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Treadlink->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 22)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Treadlink->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 22));
	return (ssize_t)host_size;
}

static ssize_t validate_Rreadlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rreadlink);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(9);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rreadlink->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 23)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rreadlink->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 23));
	return (ssize_t)host_size;
}

static ssize_t validate_Tgetattr(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tgetattr);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_request_mask = net_offset + 11;
	uint32_t offsetof_end = net_offset + 19;
	VALIDATE_NET_BYTES(19);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tgetattr->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 24)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tgetattr->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 24));
	if (GET_U64LE(offsetof_request_mask) & ~getattr_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in getattr bitfield: ",
			(base16_u64_, GET_U64LE(offsetof_request_mask) & ~getattr_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Rgetattr(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rgetattr);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_valid = net_offset + 7;
	uint32_t offsetof_qid_type = net_offset + 15;
	VALIDATE_NET_BYTES(28);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_mode = net_offset + 0;
	uint32_t offsetof_end = net_offset + 132;
	VALIDATE_NET_BYTES(132);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rgetattr->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 25)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rgetattr->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 25));
	if (GET_U64LE(offsetof_valid) & ~getattr_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in getattr bitfield: ",
			(base16_u64_, GET_U64LE(offsetof_valid) & ~getattr_masks[ctx->version]));
	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Tsetattr(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tsetattr);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_valid = net_offset + 11;
	uint32_t offsetof_mode = net_offset + 15;
	uint32_t offsetof_end = net_offset + 67;
	VALIDATE_NET_BYTES(67);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsetattr->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 26)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsetattr->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 26));
	if (GET_U32LE(offsetof_valid) & ~setattr_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in setattr bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_valid) & ~setattr_masks[ctx->version]));
	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Rsetattr(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rsetattr);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsetattr->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 27)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsetattr->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 27));
	return (ssize_t)host_size;
}

static ssize_t validate_Txattrwalk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Txattrwalk);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(17);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Txattrwalk->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 30)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Txattrwalk->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 30));
	return (ssize_t)host_size;
}

static ssize_t validate_Rxattrwalk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rxattrwalk);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 15;
	VALIDATE_NET_BYTES(15);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rxattrwalk->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 31)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rxattrwalk->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 31));
	return (ssize_t)host_size;
}

static ssize_t validate_Txattrcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Txattrcreate);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 12;
	VALIDATE_NET_BYTES(12);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Txattrcreate->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 32)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Txattrcreate->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 32));
	return (ssize_t)host_size;
}

static ssize_t validate_Rxattrcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rxattrcreate);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rxattrcreate->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 33)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rxattrcreate->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 33));
	return (ssize_t)host_size;
}

static ssize_t validate_Treaddir(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Treaddir);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 23;
	VALIDATE_NET_BYTES(23);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Treaddir->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 40)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Treaddir->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 40));
	return (ssize_t)host_size;
}

static ssize_t validate_Rreaddir(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rreaddir);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(11);
	VALIDATE_NET_BYTES(LAST_U32LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rreaddir->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 41)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rreaddir->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 41));
	return (ssize_t)host_size;
}

static ssize_t validate_Tfsync(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tfsync);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 15;
	VALIDATE_NET_BYTES(15);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tfsync->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 50)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tfsync->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 50));
	return (ssize_t)host_size;
}

static ssize_t validate_Rfsync(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rfsync);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rfsync->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 51)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rfsync->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 51));
	return (ssize_t)host_size;
}

static ssize_t validate_Tlock(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tlock);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_flags = net_offset + 12;
	VALIDATE_NET_BYTES(38);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlock->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 52)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlock->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 52));
	if (GET_U32LE(offsetof_flags) & ~lock_flags_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in lock_flags bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_flags) & ~lock_flags_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Rlock(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rlock);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 8;
	VALIDATE_NET_BYTES(8);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlock->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 53)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlock->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 53));
	return (ssize_t)host_size;
}

static ssize_t validate_Tgetlock(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tgetlock);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(34);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tgetlock->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 54)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tgetlock->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 54));
	return (ssize_t)host_size;
}

static ssize_t validate_Rgetlock(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rgetlock);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(30);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rgetlock->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 55)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rgetlock->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 55));
	return (ssize_t)host_size;
}

static ssize_t validate_Tlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tlink);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(17);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlink->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 70)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlink->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 70));
	return (ssize_t)host_size;
}

static ssize_t validate_Rlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rlink);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlink->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 71)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlink->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 71));
	return (ssize_t)host_size;
}

static ssize_t validate_Tmkdir(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tmkdir);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_mode = net_offset + 0;
	uint32_t offsetof_end = net_offset + 8;
	VALIDATE_NET_BYTES(8);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tmkdir->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 72)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tmkdir->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 72));
	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: ",
			(base16_u32_, GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]));
	return (ssize_t)host_size;
}

static ssize_t validate_Rmkdir(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rmkdir);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_qid_type = net_offset + 7;
	VALIDATE_NET_BYTES(20);
	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: ",
			(base16_u8_, GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]));
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rmkdir->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 73)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rmkdir->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 73));
	return (ssize_t)host_size;
}

static ssize_t validate_Trenameat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Trenameat);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	VALIDATE_NET_BYTES(6);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Trenameat->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 74)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Trenameat->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 74));
	return (ssize_t)host_size;
}

static ssize_t validate_Rrenameat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rrenameat);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rrenameat->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 75)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rrenameat->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 75));
	return (ssize_t)host_size;
}

static ssize_t validate_Tunlinkat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tunlinkat);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	VALIDATE_NET_UTF8(LAST_U16LE());
	uint32_t offsetof_end = net_offset + 4;
	VALIDATE_NET_BYTES(4);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tunlinkat->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 76)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tunlinkat->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 76));
	return (ssize_t)host_size;
}

static ssize_t validate_Runlinkat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Runlinkat);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Runlinkat->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 77)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Runlinkat->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 77));
	return (ssize_t)host_size;
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
static ssize_t validate_Tsession(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tsession);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 15;
	VALIDATE_NET_BYTES(15);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsession->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 150)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsession->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 150));
	return (ssize_t)host_size;
}

static ssize_t validate_Rsession(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rsession);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 7;
	VALIDATE_NET_BYTES(7);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsession->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 151)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsession->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 151));
	return (ssize_t)host_size;
}

static ssize_t validate_Tsread(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tsread);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	for (uint16_t i = 0, cnt = LAST_U16LE(); i < cnt; i++) {
		RESERVE_HOST_BYTES(sizeof(struct lib9p_s));
		VALIDATE_NET_BYTES(2);
		VALIDATE_NET_UTF8(LAST_U16LE());
	}
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsread->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 152)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsread->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 152));
	return (ssize_t)host_size;
}

static ssize_t validate_Rsread(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rsread);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(11);
	VALIDATE_NET_BYTES(LAST_U32LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsread->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 153)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsread->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 153));
	return (ssize_t)host_size;
}

static ssize_t validate_Tswrite(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Tswrite);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	VALIDATE_NET_BYTES(13);
	for (uint16_t i = 0, cnt = LAST_U16LE(); i < cnt; i++) {
		RESERVE_HOST_BYTES(sizeof(struct lib9p_s));
		VALIDATE_NET_BYTES(2);
		VALIDATE_NET_UTF8(LAST_U16LE());
	}
	VALIDATE_NET_BYTES(4);
	VALIDATE_NET_BYTES(LAST_U32LE());
	uint32_t offsetof_end = net_offset + 0;
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tswrite->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 154)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Tswrite->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 154));
	return (ssize_t)host_size;
}

static ssize_t validate_Rswrite(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes) {
	uint32_t net_offset = 0;
	ssize_t host_size = sizeof(struct lib9p_msg_Rswrite);
	uint32_t offsetof_size = net_offset + 0;
	uint32_t offsetof_typ = net_offset + 4;
	uint32_t offsetof_end = net_offset + 11;
	VALIDATE_NET_BYTES(11);
	if (GET_U32LE(offsetof_size) != offsetof_end - offsetof_size)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rswrite->size value is wrong: actual:", (base10, GET_U32LE(offsetof_size)), " != correct:", (base10, offsetof_end - offsetof_size));
	if (GET_U8LE(offsetof_typ) != 155)
		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "Rswrite->typ value is wrong: actual:", (base10, GET_U8LE(offsetof_typ)), " != correct:", (base10, 155));
	return (ssize_t)host_size;
}
#endif /* CONFIG_9P_ENABLE_9P2000_e */

/* unmarshal_* ****************************************************************/

#define UNMARSHAL_BYTES(ctx, data_lvalue, len)        \
	data_lvalue = (char *)&net_bytes[net_offset]; \
	net_offset += len;
#define UNMARSHAL_U8LE(ctx, val_lvalue)     \
	val_lvalue = net_bytes[net_offset]; \
	net_offset += 1;
#define UNMARSHAL_U16LE(ctx, val_lvalue)                      \
	val_lvalue = uint16le_decode(&net_bytes[net_offset]); \
	net_offset += 2;
#define UNMARSHAL_U32LE(ctx, val_lvalue)                      \
	val_lvalue = uint32le_decode(&net_bytes[net_offset]); \
	net_offset += 4;
#define UNMARSHAL_U64LE(ctx, val_lvalue)                      \
	val_lvalue = uint64le_decode(&net_bytes[net_offset]); \
	net_offset += 8;

#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static void unmarshal_stat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_stat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 2;
	UNMARSHAL_U16LE(ctx, out->fstype);
	UNMARSHAL_U32LE(ctx, out->fsdev);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
	UNMARSHAL_U32LE(ctx, out->mode);
	UNMARSHAL_U32LE(ctx, out->atime);
	UNMARSHAL_U32LE(ctx, out->mtime);
	UNMARSHAL_U64LE(ctx, out->length);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
	UNMARSHAL_U16LE(ctx, out->owner_uname.len);
	UNMARSHAL_BYTES(ctx, out->owner_uname.utf8, out->owner_uname.len);
	UNMARSHAL_U16LE(ctx, out->owner_gname.len);
	UNMARSHAL_BYTES(ctx, out->owner_gname.utf8, out->owner_gname.len);
	UNMARSHAL_U16LE(ctx, out->last_modifier_uname.len);
	UNMARSHAL_BYTES(ctx, out->last_modifier_uname.utf8, out->last_modifier_uname.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		UNMARSHAL_U16LE(ctx, out->extension.len);
		UNMARSHAL_BYTES(ctx, out->extension.utf8, out->extension.len);
		UNMARSHAL_U32LE(ctx, out->owner_unum);
		UNMARSHAL_U32LE(ctx, out->owner_gnum);
		UNMARSHAL_U32LE(ctx, out->last_modifier_unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
static void unmarshal_Tversion([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tversion *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->max_msg_size);
	UNMARSHAL_U16LE(ctx, out->version.len);
	UNMARSHAL_BYTES(ctx, out->version.utf8, out->version.len);
}

static void unmarshal_Rversion([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rversion *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->max_msg_size);
	UNMARSHAL_U16LE(ctx, out->version.len);
	UNMARSHAL_BYTES(ctx, out->version.utf8, out->version.len);
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static void unmarshal_Tauth([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tauth *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->afid);
	UNMARSHAL_U16LE(ctx, out->uname.len);
	UNMARSHAL_BYTES(ctx, out->uname.utf8, out->uname.len);
	UNMARSHAL_U16LE(ctx, out->aname.len);
	UNMARSHAL_BYTES(ctx, out->aname.utf8, out->aname.len);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
		UNMARSHAL_U32LE(ctx, out->unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
}

static void unmarshal_Rauth([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rauth *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->aqid.type);
	UNMARSHAL_U32LE(ctx, out->aqid.vers);
	UNMARSHAL_U64LE(ctx, out->aqid.path);
}

static void unmarshal_Tattach([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tattach *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U32LE(ctx, out->afid);
	UNMARSHAL_U16LE(ctx, out->uname.len);
	UNMARSHAL_BYTES(ctx, out->uname.utf8, out->uname.len);
	UNMARSHAL_U16LE(ctx, out->aname.len);
	UNMARSHAL_BYTES(ctx, out->aname.utf8, out->aname.len);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
		UNMARSHAL_U32LE(ctx, out->unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
}

static void unmarshal_Rattach([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rattach *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
static void unmarshal_Rerror([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rerror *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U16LE(ctx, out->errstr.len);
	UNMARSHAL_BYTES(ctx, out->errstr.utf8, out->errstr.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		UNMARSHAL_U32LE(ctx, out->errnum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static void unmarshal_Tflush([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tflush *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U16LE(ctx, out->oldtag);
}

static void unmarshal_Rflush([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rflush *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Twalk([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Twalk *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U32LE(ctx, out->newfid);
	UNMARSHAL_U16LE(ctx, out->nwname);
	out->wname = extra;
	extra += sizeof(out->wname[0]) * out->nwname;
	for (uint16_t i = 0; i < out->nwname; i++) {
		UNMARSHAL_U16LE(ctx, out->wname[i].len);
		UNMARSHAL_BYTES(ctx, out->wname[i].utf8, out->wname[i].len);
	}
}

static void unmarshal_Rwalk([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rwalk *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U16LE(ctx, out->nwqid);
	out->wqid = extra;
	extra += sizeof(out->wqid[0]) * out->nwqid;
	for (uint16_t i = 0; i < out->nwqid; i++) {
		UNMARSHAL_U8LE(ctx, out->wqid[i].type);
		UNMARSHAL_U32LE(ctx, out->wqid[i].vers);
		UNMARSHAL_U64LE(ctx, out->wqid[i].path);
	}
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static void unmarshal_Topen([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Topen *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U8LE(ctx, out->mode);
}

static void unmarshal_Ropen([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Ropen *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
	UNMARSHAL_U32LE(ctx, out->iounit);
}

static void unmarshal_Tcreate([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tcreate *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
	UNMARSHAL_U32LE(ctx, out->perm);
	UNMARSHAL_U8LE(ctx, out->mode);
}

static void unmarshal_Rcreate([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rcreate *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
	UNMARSHAL_U32LE(ctx, out->iounit);
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static void unmarshal_Tread([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tread *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U64LE(ctx, out->offset);
	UNMARSHAL_U32LE(ctx, out->count);
}

static void unmarshal_Rread([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rread *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->count);
	UNMARSHAL_BYTES(ctx, out->data, out->count);
}

static void unmarshal_Twrite([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Twrite *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U64LE(ctx, out->offset);
	UNMARSHAL_U32LE(ctx, out->count);
	UNMARSHAL_BYTES(ctx, out->data, out->count);
}

static void unmarshal_Rwrite([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rwrite *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->count);
}

static void unmarshal_Tclunk([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tclunk *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
}

static void unmarshal_Rclunk([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rclunk *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Tremove([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tremove *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
}

static void unmarshal_Rremove([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rremove *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static void unmarshal_Tstat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tstat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
}

static void unmarshal_Rstat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rstat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	net_offset += 2;
	net_offset += 2;
	UNMARSHAL_U16LE(ctx, out->stat.fstype);
	UNMARSHAL_U32LE(ctx, out->stat.fsdev);
	UNMARSHAL_U8LE(ctx, out->stat.qid.type);
	UNMARSHAL_U32LE(ctx, out->stat.qid.vers);
	UNMARSHAL_U64LE(ctx, out->stat.qid.path);
	UNMARSHAL_U32LE(ctx, out->stat.mode);
	UNMARSHAL_U32LE(ctx, out->stat.atime);
	UNMARSHAL_U32LE(ctx, out->stat.mtime);
	UNMARSHAL_U64LE(ctx, out->stat.length);
	UNMARSHAL_U16LE(ctx, out->stat.name.len);
	UNMARSHAL_BYTES(ctx, out->stat.name.utf8, out->stat.name.len);
	UNMARSHAL_U16LE(ctx, out->stat.owner_uname.len);
	UNMARSHAL_BYTES(ctx, out->stat.owner_uname.utf8, out->stat.owner_uname.len);
	UNMARSHAL_U16LE(ctx, out->stat.owner_gname.len);
	UNMARSHAL_BYTES(ctx, out->stat.owner_gname.utf8, out->stat.owner_gname.len);
	UNMARSHAL_U16LE(ctx, out->stat.last_modifier_uname.len);
	UNMARSHAL_BYTES(ctx, out->stat.last_modifier_uname.utf8, out->stat.last_modifier_uname.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		UNMARSHAL_U16LE(ctx, out->stat.extension.len);
		UNMARSHAL_BYTES(ctx, out->stat.extension.utf8, out->stat.extension.len);
		UNMARSHAL_U32LE(ctx, out->stat.owner_unum);
		UNMARSHAL_U32LE(ctx, out->stat.owner_gnum);
		UNMARSHAL_U32LE(ctx, out->stat.last_modifier_unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
}

static void unmarshal_Twstat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Twstat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	net_offset += 2;
	net_offset += 2;
	UNMARSHAL_U16LE(ctx, out->stat.fstype);
	UNMARSHAL_U32LE(ctx, out->stat.fsdev);
	UNMARSHAL_U8LE(ctx, out->stat.qid.type);
	UNMARSHAL_U32LE(ctx, out->stat.qid.vers);
	UNMARSHAL_U64LE(ctx, out->stat.qid.path);
	UNMARSHAL_U32LE(ctx, out->stat.mode);
	UNMARSHAL_U32LE(ctx, out->stat.atime);
	UNMARSHAL_U32LE(ctx, out->stat.mtime);
	UNMARSHAL_U64LE(ctx, out->stat.length);
	UNMARSHAL_U16LE(ctx, out->stat.name.len);
	UNMARSHAL_BYTES(ctx, out->stat.name.utf8, out->stat.name.len);
	UNMARSHAL_U16LE(ctx, out->stat.owner_uname.len);
	UNMARSHAL_BYTES(ctx, out->stat.owner_uname.utf8, out->stat.owner_uname.len);
	UNMARSHAL_U16LE(ctx, out->stat.owner_gname.len);
	UNMARSHAL_BYTES(ctx, out->stat.owner_gname.utf8, out->stat.owner_gname.len);
	UNMARSHAL_U16LE(ctx, out->stat.last_modifier_uname.len);
	UNMARSHAL_BYTES(ctx, out->stat.last_modifier_uname.utf8, out->stat.last_modifier_uname.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		UNMARSHAL_U16LE(ctx, out->stat.extension.len);
		UNMARSHAL_BYTES(ctx, out->stat.extension.utf8, out->stat.extension.len);
		UNMARSHAL_U32LE(ctx, out->stat.owner_unum);
		UNMARSHAL_U32LE(ctx, out->stat.owner_gnum);
		UNMARSHAL_U32LE(ctx, out->stat.last_modifier_unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
}

static void unmarshal_Rwstat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rwstat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_p9p
static void unmarshal_Topenfd([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Topenfd *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U8LE(ctx, out->mode);
}

static void unmarshal_Ropenfd([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Ropenfd *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
	UNMARSHAL_U32LE(ctx, out->iounit);
	UNMARSHAL_U32LE(ctx, out->unixfd);
}

#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_L
static void unmarshal_Rlerror([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rlerror *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->errnum);
}

static void unmarshal_Tstatfs([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tstatfs *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
}

static void unmarshal_Rstatfs([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rstatfs *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->type);
	UNMARSHAL_U32LE(ctx, out->bsize);
	UNMARSHAL_U64LE(ctx, out->blocks);
	UNMARSHAL_U64LE(ctx, out->bfree);
	UNMARSHAL_U64LE(ctx, out->bavail);
	UNMARSHAL_U64LE(ctx, out->files);
	UNMARSHAL_U64LE(ctx, out->ffree);
	UNMARSHAL_U64LE(ctx, out->fsid);
	UNMARSHAL_U32LE(ctx, out->namelen);
}

static void unmarshal_Tlopen([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tlopen *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U32LE(ctx, out->flags);
}

static void unmarshal_Rlopen([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rlopen *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
	UNMARSHAL_U32LE(ctx, out->iounit);
}

static void unmarshal_Tlcreate([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tlcreate *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
	UNMARSHAL_U32LE(ctx, out->flags);
	UNMARSHAL_U32LE(ctx, out->mode);
	UNMARSHAL_U32LE(ctx, out->gid);
}

static void unmarshal_Rlcreate([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rlcreate *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
	UNMARSHAL_U32LE(ctx, out->iounit);
}

static void unmarshal_Tsymlink([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tsymlink *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
	UNMARSHAL_U16LE(ctx, out->symtgt.len);
	UNMARSHAL_BYTES(ctx, out->symtgt.utf8, out->symtgt.len);
	UNMARSHAL_U32LE(ctx, out->gid);
}

static void unmarshal_Rsymlink([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rsymlink *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
}

static void unmarshal_Tmknod([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tmknod *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->dfid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
	UNMARSHAL_U32LE(ctx, out->mode);
	UNMARSHAL_U32LE(ctx, out->major);
	UNMARSHAL_U32LE(ctx, out->minor);
	UNMARSHAL_U32LE(ctx, out->gid);
}

static void unmarshal_Rmknod([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rmknod *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
}

static void unmarshal_Trename([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Trename *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U32LE(ctx, out->dfid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
}

static void unmarshal_Rrename([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rrename *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Treadlink([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Treadlink *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
}

static void unmarshal_Rreadlink([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rreadlink *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U16LE(ctx, out->target.len);
	UNMARSHAL_BYTES(ctx, out->target.utf8, out->target.len);
}

static void unmarshal_Tgetattr([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tgetattr *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U64LE(ctx, out->request_mask);
}

static void unmarshal_Rgetattr([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rgetattr *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U64LE(ctx, out->valid);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
	UNMARSHAL_U32LE(ctx, out->mode);
	UNMARSHAL_U32LE(ctx, out->uid);
	UNMARSHAL_U32LE(ctx, out->gid);
	UNMARSHAL_U64LE(ctx, out->nlink);
	UNMARSHAL_U64LE(ctx, out->rdev);
	UNMARSHAL_U64LE(ctx, out->filesize);
	UNMARSHAL_U64LE(ctx, out->blksize);
	UNMARSHAL_U64LE(ctx, out->blocks);
	UNMARSHAL_U64LE(ctx, out->atime_sec);
	UNMARSHAL_U64LE(ctx, out->atime_nsec);
	UNMARSHAL_U64LE(ctx, out->mtime_sec);
	UNMARSHAL_U64LE(ctx, out->mtime_nsec);
	UNMARSHAL_U64LE(ctx, out->ctime_sec);
	UNMARSHAL_U64LE(ctx, out->ctime_nsec);
	UNMARSHAL_U64LE(ctx, out->btime_sec);
	UNMARSHAL_U64LE(ctx, out->btime_nsec);
	UNMARSHAL_U64LE(ctx, out->gen);
	UNMARSHAL_U64LE(ctx, out->data_version);
}

static void unmarshal_Tsetattr([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tsetattr *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U32LE(ctx, out->valid);
	UNMARSHAL_U32LE(ctx, out->mode);
	UNMARSHAL_U32LE(ctx, out->uid);
	UNMARSHAL_U32LE(ctx, out->gid);
	UNMARSHAL_U64LE(ctx, out->filesize);
	UNMARSHAL_U64LE(ctx, out->atime_sec);
	UNMARSHAL_U64LE(ctx, out->atime_nsec);
	UNMARSHAL_U64LE(ctx, out->mtime_sec);
	UNMARSHAL_U64LE(ctx, out->mtime_nsec);
}

static void unmarshal_Rsetattr([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rsetattr *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Txattrwalk([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Txattrwalk *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U32LE(ctx, out->newfid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
}

static void unmarshal_Rxattrwalk([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rxattrwalk *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U64LE(ctx, out->attr_size);
}

static void unmarshal_Txattrcreate([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Txattrcreate *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
	UNMARSHAL_U64LE(ctx, out->attr_size);
	UNMARSHAL_U32LE(ctx, out->flags);
}

static void unmarshal_Rxattrcreate([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rxattrcreate *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Treaddir([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Treaddir *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U64LE(ctx, out->offset);
	UNMARSHAL_U32LE(ctx, out->count);
}

static void unmarshal_Rreaddir([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rreaddir *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->count);
	UNMARSHAL_BYTES(ctx, out->data, out->count);
}

static void unmarshal_Tfsync([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tfsync *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U32LE(ctx, out->datasync);
}

static void unmarshal_Rfsync([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rfsync *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Tlock([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tlock *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U8LE(ctx, out->type);
	UNMARSHAL_U32LE(ctx, out->flags);
	UNMARSHAL_U64LE(ctx, out->start);
	UNMARSHAL_U64LE(ctx, out->length);
	UNMARSHAL_U32LE(ctx, out->proc_id);
	UNMARSHAL_U16LE(ctx, out->client_id.len);
	UNMARSHAL_BYTES(ctx, out->client_id.utf8, out->client_id.len);
}

static void unmarshal_Rlock([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rlock *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->status);
}

static void unmarshal_Tgetlock([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tgetlock *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U8LE(ctx, out->type);
	UNMARSHAL_U64LE(ctx, out->start);
	UNMARSHAL_U64LE(ctx, out->length);
	UNMARSHAL_U32LE(ctx, out->proc_id);
	UNMARSHAL_U16LE(ctx, out->client_id.len);
	UNMARSHAL_BYTES(ctx, out->client_id.utf8, out->client_id.len);
}

static void unmarshal_Rgetlock([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rgetlock *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->type);
	UNMARSHAL_U64LE(ctx, out->start);
	UNMARSHAL_U64LE(ctx, out->length);
	UNMARSHAL_U32LE(ctx, out->proc_id);
	UNMARSHAL_U16LE(ctx, out->client_id.len);
	UNMARSHAL_BYTES(ctx, out->client_id.utf8, out->client_id.len);
}

static void unmarshal_Tlink([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tlink *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->dfid);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
}

static void unmarshal_Rlink([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rlink *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Tmkdir([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tmkdir *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->dfid);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
	UNMARSHAL_U32LE(ctx, out->mode);
	UNMARSHAL_U32LE(ctx, out->gid);
}

static void unmarshal_Rmkdir([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rmkdir *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U8LE(ctx, out->qid.type);
	UNMARSHAL_U32LE(ctx, out->qid.vers);
	UNMARSHAL_U64LE(ctx, out->qid.path);
}

static void unmarshal_Trenameat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Trenameat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->olddirfid);
	UNMARSHAL_U16LE(ctx, out->oldname.len);
	UNMARSHAL_BYTES(ctx, out->oldname.utf8, out->oldname.len);
	UNMARSHAL_U32LE(ctx, out->newdirfid);
	UNMARSHAL_U16LE(ctx, out->newname.len);
	UNMARSHAL_BYTES(ctx, out->newname.utf8, out->newname.len);
}

static void unmarshal_Rrenameat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rrenameat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Tunlinkat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tunlinkat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->dirfd);
	UNMARSHAL_U16LE(ctx, out->name.len);
	UNMARSHAL_BYTES(ctx, out->name.utf8, out->name.len);
	UNMARSHAL_U32LE(ctx, out->flags);
}

static void unmarshal_Runlinkat([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Runlinkat *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
static void unmarshal_Tsession([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tsession *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U64LE(ctx, out->key);
}

static void unmarshal_Rsession([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rsession *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
}

static void unmarshal_Tsread([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tsread *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U16LE(ctx, out->nwname);
	out->wname = extra;
	extra += sizeof(out->wname[0]) * out->nwname;
	for (uint16_t i = 0; i < out->nwname; i++) {
		UNMARSHAL_U16LE(ctx, out->wname[i].len);
		UNMARSHAL_BYTES(ctx, out->wname[i].utf8, out->wname[i].len);
	}
}

static void unmarshal_Rsread([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rsread *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->count);
	UNMARSHAL_BYTES(ctx, out->data, out->count);
}

static void unmarshal_Tswrite([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Tswrite *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->fid);
	UNMARSHAL_U16LE(ctx, out->nwname);
	out->wname = extra;
	extra += sizeof(out->wname[0]) * out->nwname;
	for (uint16_t i = 0; i < out->nwname; i++) {
		UNMARSHAL_U16LE(ctx, out->wname[i].len);
		UNMARSHAL_BYTES(ctx, out->wname[i].utf8, out->wname[i].len);
	}
	UNMARSHAL_U32LE(ctx, out->count);
	UNMARSHAL_BYTES(ctx, out->data, out->count);
}

static void unmarshal_Rswrite([[maybe_unused]] struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out_buf) {
	struct lib9p_msg_Rswrite *out = out_buf;
	[[maybe_unused]] void *extra = &out[1];
	uint32_t net_offset = 0;
	net_offset += 4;
	net_offset += 1;
	UNMARSHAL_U16LE(ctx, out->tag);
	UNMARSHAL_U32LE(ctx, out->count);
}
#endif /* CONFIG_9P_ENABLE_9P2000_e */

/* marshal_* ******************************************************************/

#define MARSHAL_BYTES_ZEROCOPY(ctx, data, len)            \
	if (ret->net_iov[ret->net_iov_cnt-1].iov_len)     \
		ret->net_iov_cnt++;                       \
	ret->net_iov[ret->net_iov_cnt-1].iov_base = data; \
	ret->net_iov[ret->net_iov_cnt-1].iov_len = len;   \
	ret->net_iov_cnt++;
#define MARSHAL_BYTES(ctx, data, len)                                                               \
	if (!ret->net_iov[ret->net_iov_cnt-1].iov_base)                                             \
		ret->net_iov[ret->net_iov_cnt-1].iov_base = &ret->net_copied[ret->net_copied_size]; \
	memcpy(&ret->net_copied[ret->net_copied_size], data, len);                                  \
	ret->net_copied_size += len;                                                                \
	ret->net_iov[ret->net_iov_cnt-1].iov_len += len;
#define MARSHAL_U8LE(ctx, val)                                                                      \
	if (!ret->net_iov[ret->net_iov_cnt-1].iov_base)                                             \
		ret->net_iov[ret->net_iov_cnt-1].iov_base = &ret->net_copied[ret->net_copied_size]; \
	ret->net_copied[ret->net_copied_size] = val;                                                \
	ret->net_copied_size += 1;                                                                  \
	ret->net_iov[ret->net_iov_cnt-1].iov_len += 1;
#define MARSHAL_U16LE(ctx, val)                                                                     \
	if (!ret->net_iov[ret->net_iov_cnt-1].iov_base)                                             \
		ret->net_iov[ret->net_iov_cnt-1].iov_base = &ret->net_copied[ret->net_copied_size]; \
	uint16le_encode(&ret->net_copied[ret->net_copied_size], val);                               \
	ret->net_copied_size += 2;                                                                  \
	ret->net_iov[ret->net_iov_cnt-1].iov_len += 2;
#define MARSHAL_U32LE(ctx, val)                                                                     \
	if (!ret->net_iov[ret->net_iov_cnt-1].iov_base)                                             \
		ret->net_iov[ret->net_iov_cnt-1].iov_base = &ret->net_copied[ret->net_copied_size]; \
	uint32le_encode(&ret->net_copied[ret->net_copied_size], val);                               \
	ret->net_copied_size += 4;                                                                  \
	ret->net_iov[ret->net_iov_cnt-1].iov_len += 4;
#define MARSHAL_U64LE(ctx, val)                                                                     \
	if (!ret->net_iov[ret->net_iov_cnt-1].iov_base)                                             \
		ret->net_iov[ret->net_iov_cnt-1].iov_base = &ret->net_copied[ret->net_copied_size]; \
	uint64le_encode(&ret->net_copied[ret->net_copied_size], val);                               \
	ret->net_copied_size += 8;                                                                  \
	ret->net_iov[ret->net_iov_cnt-1].iov_len += 8;

#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_stat(struct lib9p_ctx *ctx, struct lib9p_stat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 49 + val->name.len + val->owner_uname.len + val->owner_gname.len + val->last_modifier_uname.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		needed_size += 14 + val->extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->max_msg_size) {
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_fstype = 2;
	MARSHAL_U16LE(ctx, offsetof_end - offsetof_fstype);
	MARSHAL_U16LE(ctx, val->fstype);
	MARSHAL_U32LE(ctx, val->fsdev);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->mode & dm_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->atime);
	MARSHAL_U32LE(ctx, val->mtime);
	MARSHAL_U64LE(ctx, val->length);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES(ctx, val->name.utf8, val->name.len);
	MARSHAL_U16LE(ctx, val->owner_uname.len);
	MARSHAL_BYTES(ctx, val->owner_uname.utf8, val->owner_uname.len);
	MARSHAL_U16LE(ctx, val->owner_gname.len);
	MARSHAL_BYTES(ctx, val->owner_gname.utf8, val->owner_gname.len);
	MARSHAL_U16LE(ctx, val->last_modifier_uname.len);
	MARSHAL_BYTES(ctx, val->last_modifier_uname.utf8, val->last_modifier_uname.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U16LE(ctx, val->extension.len);
		MARSHAL_BYTES(ctx, val->extension.utf8, val->extension.len);
		MARSHAL_U32LE(ctx, val->owner_unum);
		MARSHAL_U32LE(ctx, val->owner_gnum);
		MARSHAL_U32LE(ctx, val->last_modifier_unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
static bool marshal_Tversion(struct lib9p_ctx *ctx, struct lib9p_msg_Tversion *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 13 + val->version.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tversion message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 100);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->max_msg_size);
	MARSHAL_U16LE(ctx, val->version.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->version.utf8, val->version.len);
	return false;
}

static bool marshal_Rversion(struct lib9p_ctx *ctx, struct lib9p_msg_Rversion *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 13 + val->version.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rversion message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 101);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->max_msg_size);
	MARSHAL_U16LE(ctx, val->version.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->version.utf8, val->version.len);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_Tauth(struct lib9p_ctx *ctx, struct lib9p_msg_Tauth *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 15 + val->uname.len + val->aname.len;
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if ( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) ) {
		needed_size += 4;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tauth message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 102);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->afid);
	MARSHAL_U16LE(ctx, val->uname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->uname.utf8, val->uname.len);
	MARSHAL_U16LE(ctx, val->aname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->aname.utf8, val->aname.len);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
		MARSHAL_U32LE(ctx, val->unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Rauth(struct lib9p_ctx *ctx, struct lib9p_msg_Rauth *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rauth message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 103);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->aqid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->aqid.vers);
	MARSHAL_U64LE(ctx, val->aqid.path);
	return false;
}

static bool marshal_Tattach(struct lib9p_ctx *ctx, struct lib9p_msg_Tattach *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 19 + val->uname.len + val->aname.len;
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if ( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) ) {
		needed_size += 4;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tattach message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 104);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->afid);
	MARSHAL_U16LE(ctx, val->uname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->uname.utf8, val->uname.len);
	MARSHAL_U16LE(ctx, val->aname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->aname.utf8, val->aname.len);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
		MARSHAL_U32LE(ctx, val->unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Rattach(struct lib9p_ctx *ctx, struct lib9p_msg_Rattach *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rattach message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 105);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
static bool marshal_Rerror(struct lib9p_ctx *ctx, struct lib9p_msg_Rerror *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 9 + val->errstr.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		needed_size += 4;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rerror message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 107);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, val->errstr.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->errstr.utf8, val->errstr.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->errnum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_Tflush(struct lib9p_ctx *ctx, struct lib9p_msg_Tflush *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 9;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tflush message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 108);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, val->oldtag);
	return false;
}

static bool marshal_Rflush(struct lib9p_ctx *ctx, struct lib9p_msg_Rflush *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rflush message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 109);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Twalk(struct lib9p_ctx *ctx, struct lib9p_msg_Twalk *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 17;
	for (uint16_t i = 0; i < val->nwname; i++) {
		needed_size += 2 + val->wname[i].len;
	}
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Twalk message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 110);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->newfid);
	MARSHAL_U16LE(ctx, val->nwname);
	for (uint16_t i = 0; i < val->nwname; i++) {
		MARSHAL_U16LE(ctx, val->wname[i].len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->wname[i].utf8, val->wname[i].len);
	}
	return false;
}

static bool marshal_Rwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Rwalk *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 9 + (val->nwqid)*13;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rwalk message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 111);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, val->nwqid);
	for (uint16_t i = 0; i < val->nwqid; i++) {
		MARSHAL_U8LE(ctx, val->wqid[i].type & qt_masks[ctx->version]);
		MARSHAL_U32LE(ctx, val->wqid[i].vers);
		MARSHAL_U64LE(ctx, val->wqid[i].path);
	}
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_Topen(struct lib9p_ctx *ctx, struct lib9p_msg_Topen *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 12;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Topen message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 112);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U8LE(ctx, val->mode & o_masks[ctx->version]);
	return false;
}

static bool marshal_Ropen(struct lib9p_ctx *ctx, struct lib9p_msg_Ropen *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 24;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Ropen message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 113);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	return false;
}

static bool marshal_Tcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Tcreate *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 18 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tcreate message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 114);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->perm & dm_masks[ctx->version]);
	MARSHAL_U8LE(ctx, val->mode & o_masks[ctx->version]);
	return false;
}

static bool marshal_Rcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rcreate *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 24;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rcreate message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 115);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_Tread(struct lib9p_ctx *ctx, struct lib9p_msg_Tread *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 23;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tread message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 116);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U64LE(ctx, val->offset);
	MARSHAL_U32LE(ctx, val->count);
	return false;
}

static bool marshal_Rread(struct lib9p_ctx *ctx, struct lib9p_msg_Rread *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11 + val->count;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rread message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 117);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Twrite(struct lib9p_ctx *ctx, struct lib9p_msg_Twrite *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 23 + val->count;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Twrite message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 118);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U64LE(ctx, val->offset);
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Rwrite(struct lib9p_ctx *ctx, struct lib9p_msg_Rwrite *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rwrite message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 119);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	return false;
}

static bool marshal_Tclunk(struct lib9p_ctx *ctx, struct lib9p_msg_Tclunk *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tclunk message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 120);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rclunk(struct lib9p_ctx *ctx, struct lib9p_msg_Rclunk *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rclunk message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 121);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tremove(struct lib9p_ctx *ctx, struct lib9p_msg_Tremove *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tremove message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 122);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rremove(struct lib9p_ctx *ctx, struct lib9p_msg_Rremove *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rremove message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 123);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_Tstat(struct lib9p_ctx *ctx, struct lib9p_msg_Tstat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tstat message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 124);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rstat(struct lib9p_ctx *ctx, struct lib9p_msg_Rstat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 58 + val->stat.name.len + val->stat.owner_uname.len + val->stat.owner_gname.len + val->stat.last_modifier_uname.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		needed_size += 14 + val->stat.extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rstat message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	uint32_t offsetof_stat = 9;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 125);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, offsetof_end - offsetof_stat);
	uint32_t offsetof_stat_end = 49 + val->stat.name.len + val->stat.owner_uname.len + val->stat.owner_gname.len + val->stat.last_modifier_uname.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		offsetof_stat_end += 14 + val->stat.extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_stat_fstype = 2;
	MARSHAL_U16LE(ctx, offsetof_stat_end - offsetof_stat_fstype);
	MARSHAL_U16LE(ctx, val->stat.fstype);
	MARSHAL_U32LE(ctx, val->stat.fsdev);
	MARSHAL_U8LE(ctx, val->stat.qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->stat.qid.vers);
	MARSHAL_U64LE(ctx, val->stat.qid.path);
	MARSHAL_U32LE(ctx, val->stat.mode & dm_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->stat.atime);
	MARSHAL_U32LE(ctx, val->stat.mtime);
	MARSHAL_U64LE(ctx, val->stat.length);
	MARSHAL_U16LE(ctx, val->stat.name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.name.utf8, val->stat.name.len);
	MARSHAL_U16LE(ctx, val->stat.owner_uname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.owner_uname.utf8, val->stat.owner_uname.len);
	MARSHAL_U16LE(ctx, val->stat.owner_gname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.owner_gname.utf8, val->stat.owner_gname.len);
	MARSHAL_U16LE(ctx, val->stat.last_modifier_uname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.last_modifier_uname.utf8, val->stat.last_modifier_uname.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U16LE(ctx, val->stat.extension.len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.extension.utf8, val->stat.extension.len);
		MARSHAL_U32LE(ctx, val->stat.owner_unum);
		MARSHAL_U32LE(ctx, val->stat.owner_gnum);
		MARSHAL_U32LE(ctx, val->stat.last_modifier_unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Twstat(struct lib9p_ctx *ctx, struct lib9p_msg_Twstat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 62 + val->stat.name.len + val->stat.owner_uname.len + val->stat.owner_gname.len + val->stat.last_modifier_uname.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		needed_size += 14 + val->stat.extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Twstat message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	uint32_t offsetof_stat = 13;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 126);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, offsetof_end - offsetof_stat);
	uint32_t offsetof_stat_end = 49 + val->stat.name.len + val->stat.owner_uname.len + val->stat.owner_gname.len + val->stat.last_modifier_uname.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		offsetof_stat_end += 14 + val->stat.extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_stat_fstype = 2;
	MARSHAL_U16LE(ctx, offsetof_stat_end - offsetof_stat_fstype);
	MARSHAL_U16LE(ctx, val->stat.fstype);
	MARSHAL_U32LE(ctx, val->stat.fsdev);
	MARSHAL_U8LE(ctx, val->stat.qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->stat.qid.vers);
	MARSHAL_U64LE(ctx, val->stat.qid.path);
	MARSHAL_U32LE(ctx, val->stat.mode & dm_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->stat.atime);
	MARSHAL_U32LE(ctx, val->stat.mtime);
	MARSHAL_U64LE(ctx, val->stat.length);
	MARSHAL_U16LE(ctx, val->stat.name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.name.utf8, val->stat.name.len);
	MARSHAL_U16LE(ctx, val->stat.owner_uname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.owner_uname.utf8, val->stat.owner_uname.len);
	MARSHAL_U16LE(ctx, val->stat.owner_gname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.owner_gname.utf8, val->stat.owner_gname.len);
	MARSHAL_U16LE(ctx, val->stat.last_modifier_uname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.last_modifier_uname.utf8, val->stat.last_modifier_uname.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U16LE(ctx, val->stat.extension.len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.extension.utf8, val->stat.extension.len);
		MARSHAL_U32LE(ctx, val->stat.owner_unum);
		MARSHAL_U32LE(ctx, val->stat.owner_gnum);
		MARSHAL_U32LE(ctx, val->stat.last_modifier_unum);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Rwstat(struct lib9p_ctx *ctx, struct lib9p_msg_Rwstat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rwstat message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 127);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_p9p
static bool marshal_Topenfd(struct lib9p_ctx *ctx, struct lib9p_msg_Topenfd *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 12;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Topenfd message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 98);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U8LE(ctx, val->mode & o_masks[ctx->version]);
	return false;
}

static bool marshal_Ropenfd(struct lib9p_ctx *ctx, struct lib9p_msg_Ropenfd *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 28;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Ropenfd message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 99);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	MARSHAL_U32LE(ctx, val->unixfd);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_L
static bool marshal_Rlerror(struct lib9p_ctx *ctx, struct lib9p_msg_Rlerror *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rlerror message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 7);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->errnum);
	return false;
}

static bool marshal_Tstatfs(struct lib9p_ctx *ctx, struct lib9p_msg_Tstatfs *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tstatfs message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 8);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rstatfs(struct lib9p_ctx *ctx, struct lib9p_msg_Rstatfs *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 67;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rstatfs message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 9);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->type);
	MARSHAL_U32LE(ctx, val->bsize);
	MARSHAL_U64LE(ctx, val->blocks);
	MARSHAL_U64LE(ctx, val->bfree);
	MARSHAL_U64LE(ctx, val->bavail);
	MARSHAL_U64LE(ctx, val->files);
	MARSHAL_U64LE(ctx, val->ffree);
	MARSHAL_U64LE(ctx, val->fsid);
	MARSHAL_U32LE(ctx, val->namelen);
	return false;
}

static bool marshal_Tlopen(struct lib9p_ctx *ctx, struct lib9p_msg_Tlopen *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 15;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tlopen message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 12);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->flags & lo_masks[ctx->version]);
	return false;
}

static bool marshal_Rlopen(struct lib9p_ctx *ctx, struct lib9p_msg_Rlopen *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 24;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rlopen message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 13);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	return false;
}

static bool marshal_Tlcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Tlcreate *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 25 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tlcreate message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 14);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->flags & lo_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->mode & mode_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->gid);
	return false;
}

static bool marshal_Rlcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rlcreate *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 24;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rlcreate message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 15);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	return false;
}

static bool marshal_Tsymlink(struct lib9p_ctx *ctx, struct lib9p_msg_Tsymlink *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 19 + val->name.len + val->symtgt.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tsymlink message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 16);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U16LE(ctx, val->symtgt.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->symtgt.utf8, val->symtgt.len);
	MARSHAL_U32LE(ctx, val->gid);
	return false;
}

static bool marshal_Rsymlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rsymlink *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rsymlink message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 17);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	return false;
}

static bool marshal_Tmknod(struct lib9p_ctx *ctx, struct lib9p_msg_Tmknod *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 29 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tmknod message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 18);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->dfid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->mode & mode_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->major);
	MARSHAL_U32LE(ctx, val->minor);
	MARSHAL_U32LE(ctx, val->gid);
	return false;
}

static bool marshal_Rmknod(struct lib9p_ctx *ctx, struct lib9p_msg_Rmknod *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rmknod message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 19);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	return false;
}

static bool marshal_Trename(struct lib9p_ctx *ctx, struct lib9p_msg_Trename *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 17 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Trename message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 20);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->dfid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	return false;
}

static bool marshal_Rrename(struct lib9p_ctx *ctx, struct lib9p_msg_Rrename *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rrename message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 21);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Treadlink(struct lib9p_ctx *ctx, struct lib9p_msg_Treadlink *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Treadlink message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 22);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rreadlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rreadlink *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 9 + val->target.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rreadlink message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 23);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, val->target.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->target.utf8, val->target.len);
	return false;
}

static bool marshal_Tgetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Tgetattr *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 19;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tgetattr message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 24);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U64LE(ctx, val->request_mask & getattr_masks[ctx->version]);
	return false;
}

static bool marshal_Rgetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Rgetattr *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 160;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rgetattr message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 25);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U64LE(ctx, val->valid & getattr_masks[ctx->version]);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->mode & mode_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->uid);
	MARSHAL_U32LE(ctx, val->gid);
	MARSHAL_U64LE(ctx, val->nlink);
	MARSHAL_U64LE(ctx, val->rdev);
	MARSHAL_U64LE(ctx, val->filesize);
	MARSHAL_U64LE(ctx, val->blksize);
	MARSHAL_U64LE(ctx, val->blocks);
	MARSHAL_U64LE(ctx, val->atime_sec);
	MARSHAL_U64LE(ctx, val->atime_nsec);
	MARSHAL_U64LE(ctx, val->mtime_sec);
	MARSHAL_U64LE(ctx, val->mtime_nsec);
	MARSHAL_U64LE(ctx, val->ctime_sec);
	MARSHAL_U64LE(ctx, val->ctime_nsec);
	MARSHAL_U64LE(ctx, val->btime_sec);
	MARSHAL_U64LE(ctx, val->btime_nsec);
	MARSHAL_U64LE(ctx, val->gen);
	MARSHAL_U64LE(ctx, val->data_version);
	return false;
}

static bool marshal_Tsetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Tsetattr *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 67;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tsetattr message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 26);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->valid & setattr_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->mode & mode_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->uid);
	MARSHAL_U32LE(ctx, val->gid);
	MARSHAL_U64LE(ctx, val->filesize);
	MARSHAL_U64LE(ctx, val->atime_sec);
	MARSHAL_U64LE(ctx, val->atime_nsec);
	MARSHAL_U64LE(ctx, val->mtime_sec);
	MARSHAL_U64LE(ctx, val->mtime_nsec);
	return false;
}

static bool marshal_Rsetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Rsetattr *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rsetattr message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 27);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Txattrwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Txattrwalk *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 17 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Txattrwalk message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 30);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->newfid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	return false;
}

static bool marshal_Rxattrwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Rxattrwalk *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 15;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rxattrwalk message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 31);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U64LE(ctx, val->attr_size);
	return false;
}

static bool marshal_Txattrcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Txattrcreate *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 25 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Txattrcreate message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 32);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U64LE(ctx, val->attr_size);
	MARSHAL_U32LE(ctx, val->flags);
	return false;
}

static bool marshal_Rxattrcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rxattrcreate *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rxattrcreate message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 33);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Treaddir(struct lib9p_ctx *ctx, struct lib9p_msg_Treaddir *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 23;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Treaddir message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 40);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U64LE(ctx, val->offset);
	MARSHAL_U32LE(ctx, val->count);
	return false;
}

static bool marshal_Rreaddir(struct lib9p_ctx *ctx, struct lib9p_msg_Rreaddir *val, struct _marshal_ret *ret) {
	uint64_t needed_size = 11 + val->count;
	if (needed_size > (uint64_t)(ctx->max_msg_size)) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rreaddir message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = (uint32_t)needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 41);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Tfsync(struct lib9p_ctx *ctx, struct lib9p_msg_Tfsync *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 15;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tfsync message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 50);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->datasync);
	return false;
}

static bool marshal_Rfsync(struct lib9p_ctx *ctx, struct lib9p_msg_Rfsync *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rfsync message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 51);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tlock(struct lib9p_ctx *ctx, struct lib9p_msg_Tlock *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 38 + val->client_id.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tlock message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 52);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U8LE(ctx, val->type);
	MARSHAL_U32LE(ctx, val->flags & lock_flags_masks[ctx->version]);
	MARSHAL_U64LE(ctx, val->start);
	MARSHAL_U64LE(ctx, val->length);
	MARSHAL_U32LE(ctx, val->proc_id);
	MARSHAL_U16LE(ctx, val->client_id.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->client_id.utf8, val->client_id.len);
	return false;
}

static bool marshal_Rlock(struct lib9p_ctx *ctx, struct lib9p_msg_Rlock *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 8;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rlock message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 53);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->status);
	return false;
}

static bool marshal_Tgetlock(struct lib9p_ctx *ctx, struct lib9p_msg_Tgetlock *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 34 + val->client_id.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tgetlock message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 54);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U8LE(ctx, val->type);
	MARSHAL_U64LE(ctx, val->start);
	MARSHAL_U64LE(ctx, val->length);
	MARSHAL_U32LE(ctx, val->proc_id);
	MARSHAL_U16LE(ctx, val->client_id.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->client_id.utf8, val->client_id.len);
	return false;
}

static bool marshal_Rgetlock(struct lib9p_ctx *ctx, struct lib9p_msg_Rgetlock *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 30 + val->client_id.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rgetlock message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 55);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->type);
	MARSHAL_U64LE(ctx, val->start);
	MARSHAL_U64LE(ctx, val->length);
	MARSHAL_U32LE(ctx, val->proc_id);
	MARSHAL_U16LE(ctx, val->client_id.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->client_id.utf8, val->client_id.len);
	return false;
}

static bool marshal_Tlink(struct lib9p_ctx *ctx, struct lib9p_msg_Tlink *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 17 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tlink message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 70);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->dfid);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	return false;
}

static bool marshal_Rlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rlink *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rlink message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 71);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tmkdir(struct lib9p_ctx *ctx, struct lib9p_msg_Tmkdir *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 21 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tmkdir message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 72);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->dfid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->mode & mode_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->gid);
	return false;
}

static bool marshal_Rmkdir(struct lib9p_ctx *ctx, struct lib9p_msg_Rmkdir *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rmkdir message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 73);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	return false;
}

static bool marshal_Trenameat(struct lib9p_ctx *ctx, struct lib9p_msg_Trenameat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 19 + val->oldname.len + val->newname.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Trenameat message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 74);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->olddirfid);
	MARSHAL_U16LE(ctx, val->oldname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->oldname.utf8, val->oldname.len);
	MARSHAL_U32LE(ctx, val->newdirfid);
	MARSHAL_U16LE(ctx, val->newname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->newname.utf8, val->newname.len);
	return false;
}

static bool marshal_Rrenameat(struct lib9p_ctx *ctx, struct lib9p_msg_Rrenameat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rrenameat message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 75);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tunlinkat(struct lib9p_ctx *ctx, struct lib9p_msg_Tunlinkat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 17 + val->name.len;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tunlinkat message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 76);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->dirfd);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->flags);
	return false;
}

static bool marshal_Runlinkat(struct lib9p_ctx *ctx, struct lib9p_msg_Runlinkat *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Runlinkat message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 77);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
static bool marshal_Tsession(struct lib9p_ctx *ctx, struct lib9p_msg_Tsession *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 15;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tsession message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 150);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U64LE(ctx, val->key);
	return false;
}

static bool marshal_Rsession(struct lib9p_ctx *ctx, struct lib9p_msg_Rsession *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rsession message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 151);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tsread(struct lib9p_ctx *ctx, struct lib9p_msg_Tsread *val, struct _marshal_ret *ret) {
	uint64_t needed_size = 13;
	for (uint16_t i = 0; i < val->nwname; i++) {
		needed_size += 2 + val->wname[i].len;
	}
	if (needed_size > (uint64_t)(ctx->max_msg_size)) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tsread message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = (uint32_t)needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 152);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->nwname);
	for (uint16_t i = 0; i < val->nwname; i++) {
		MARSHAL_U16LE(ctx, val->wname[i].len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->wname[i].utf8, val->wname[i].len);
	}
	return false;
}

static bool marshal_Rsread(struct lib9p_ctx *ctx, struct lib9p_msg_Rsread *val, struct _marshal_ret *ret) {
	uint64_t needed_size = 11 + val->count;
	if (needed_size > (uint64_t)(ctx->max_msg_size)) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rsread message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = (uint32_t)needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 153);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Tswrite(struct lib9p_ctx *ctx, struct lib9p_msg_Tswrite *val, struct _marshal_ret *ret) {
	uint64_t needed_size = 17 + val->count;
	for (uint16_t i = 0; i < val->nwname; i++) {
		needed_size += 2 + val->wname[i].len;
	}
	if (needed_size > (uint64_t)(ctx->max_msg_size)) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Tswrite message too large to marshal into ",
			ctx->version ? "negotiated" : "client", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = (uint32_t)needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 154);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->nwname);
	for (uint16_t i = 0; i < val->nwname; i++) {
		MARSHAL_U16LE(ctx, val->wname[i].len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->wname[i].utf8, val->wname[i].len);
	}
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Rswrite(struct lib9p_ctx *ctx, struct lib9p_msg_Rswrite *val, struct _marshal_ret *ret) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->max_msg_size) {
		lib9p_error(ctx, LIB9P_ERRNO_L_ERANGE, "Rswrite message too large to marshal into ",
			ctx->version ? "negotiated" : "server", " limit",
			" (", needed_size, " > ", ctx->max_msg_size, ")");
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 155);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	return false;
}
#endif /* CONFIG_9P_ENABLE_9P2000_e */

/* fmt_print_* ****************************************************************/

#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
[[maybe_unused]] static void fmt_print_tag(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_tag_t *self) {
	switch (*self) {
	case LIB9P_TAG_NOTAG:
		fmt_print_str(w, "NOTAG");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

[[maybe_unused]] static void fmt_print_fid(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_fid_t *self) {
	switch (*self) {
	case LIB9P_FID_NOFID:
		fmt_print_str(w, "NOFID");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
[[maybe_unused]] static void fmt_print_dm(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_dm_t *self) {
	bool empty = true;
	fmt_print_byte(w, '(');
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<31)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "DIR");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<30)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "APPEND");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<29)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "EXCL");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<28)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "_PLAN9_MOUNT");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<27)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "AUTH");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<26)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "TMP");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<25)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<25");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<24)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<24");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<23)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "DEVICE");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<22)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<22");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<21)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PIPE");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<20)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "SOCKET");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<19)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "SETUID");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<18)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "SETGID");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<17)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<17");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<16)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<16");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<15)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<15");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<14)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<14");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<13)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<13");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<12)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<12");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<11)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<11");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<10)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<10");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<9)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<9");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<8)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "OWNER_R");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<7)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "OWNER_W");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<6)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "OWNER_X");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<5)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "GROUP_R");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<4)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "GROUP_W");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<3)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "GROUP_X");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<2)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "OTHER_R");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<1)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "OTHER_W");
		empty = false;
	}
	if ((*self & ~((lib9p_dm_t)0777)) & (UINT32_C(1)<<0)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "OTHER_X");
		empty = false;
	}
	if (!empty)
		fmt_print_byte(w, '|');
	fmt_print(w, (rjust, 4, '0', (base8, *self & 0777)));
	fmt_print_byte(w, ')');
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
[[maybe_unused]] static void fmt_print_qt(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_qt_t *self) {
	bool empty = true;
	fmt_print_byte(w, '(');
	if (*self & (UINT8_C(1)<<7)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "DIR");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<6)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "APPEND");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<5)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "EXCL");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<4)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "_PLAN9_MOUNT");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<3)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "AUTH");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<2)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "TMP");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<1)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "SYMLINK");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<0)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<0");
		empty = false;
	}
	if (empty)
		fmt_print_byte(w, '0');
	fmt_print_byte(w, ')');
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_o(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_o_t *self) {
	bool empty = true;
	fmt_print_byte(w, '(');
	if (*self & (UINT8_C(1)<<7)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<7");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<6)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "RCLOSE");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<5)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "CEXEC");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<4)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "TRUNC");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<3)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<3");
		empty = false;
	}
	if (*self & (UINT8_C(1)<<2)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<2");
		empty = false;
	}
	switch (*self & LIB9P_O_MODE_MASK) {
	case LIB9P_O_MODE_READ:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE_READ");
		empty = false;
		break;
	case LIB9P_O_MODE_WRITE:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE_WRITE");
		empty = false;
		break;
	case LIB9P_O_MODE_RDWR:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE_RDWR");
		empty = false;
		break;
	case LIB9P_O_MODE_EXEC:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE_EXEC");
		empty = false;
		break;
	default:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_base10(w, *self & LIB9P_O_MODE_MASK);
		empty = false;
	}
	if (empty)
		fmt_print_byte(w, '0');
	fmt_print_byte(w, ')');
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_nuid(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_nuid_t *self) {
	switch (*self) {
	case LIB9P_NUID_NONUID:
		fmt_print_str(w, "NONUID");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

[[maybe_unused]] static void fmt_print_errno(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_errno_t *self) {
	switch (*self) {
	case LIB9P_ERRNO_NOERROR:
		fmt_print_str(w, "NOERROR");
		break;
	case LIB9P_ERRNO_L_EPERM:
		fmt_print_str(w, "L_EPERM");
		break;
	case LIB9P_ERRNO_L_ENOENT:
		fmt_print_str(w, "L_ENOENT");
		break;
	case LIB9P_ERRNO_L_ESRCH:
		fmt_print_str(w, "L_ESRCH");
		break;
	case LIB9P_ERRNO_L_EINTR:
		fmt_print_str(w, "L_EINTR");
		break;
	case LIB9P_ERRNO_L_EIO:
		fmt_print_str(w, "L_EIO");
		break;
	case LIB9P_ERRNO_L_ENXIO:
		fmt_print_str(w, "L_ENXIO");
		break;
	case LIB9P_ERRNO_L_E2BIG:
		fmt_print_str(w, "L_E2BIG");
		break;
	case LIB9P_ERRNO_L_ENOEXEC:
		fmt_print_str(w, "L_ENOEXEC");
		break;
	case LIB9P_ERRNO_L_EBADF:
		fmt_print_str(w, "L_EBADF");
		break;
	case LIB9P_ERRNO_L_ECHILD:
		fmt_print_str(w, "L_ECHILD");
		break;
	case LIB9P_ERRNO_L_EAGAIN:
		fmt_print_str(w, "L_EAGAIN");
		break;
	case LIB9P_ERRNO_L_ENOMEM:
		fmt_print_str(w, "L_ENOMEM");
		break;
	case LIB9P_ERRNO_L_EACCES:
		fmt_print_str(w, "L_EACCES");
		break;
	case LIB9P_ERRNO_L_EFAULT:
		fmt_print_str(w, "L_EFAULT");
		break;
	case LIB9P_ERRNO_L_ENOTBLK:
		fmt_print_str(w, "L_ENOTBLK");
		break;
	case LIB9P_ERRNO_L_EBUSY:
		fmt_print_str(w, "L_EBUSY");
		break;
	case LIB9P_ERRNO_L_EEXIST:
		fmt_print_str(w, "L_EEXIST");
		break;
	case LIB9P_ERRNO_L_EXDEV:
		fmt_print_str(w, "L_EXDEV");
		break;
	case LIB9P_ERRNO_L_ENODEV:
		fmt_print_str(w, "L_ENODEV");
		break;
	case LIB9P_ERRNO_L_ENOTDIR:
		fmt_print_str(w, "L_ENOTDIR");
		break;
	case LIB9P_ERRNO_L_EISDIR:
		fmt_print_str(w, "L_EISDIR");
		break;
	case LIB9P_ERRNO_L_EINVAL:
		fmt_print_str(w, "L_EINVAL");
		break;
	case LIB9P_ERRNO_L_ENFILE:
		fmt_print_str(w, "L_ENFILE");
		break;
	case LIB9P_ERRNO_L_EMFILE:
		fmt_print_str(w, "L_EMFILE");
		break;
	case LIB9P_ERRNO_L_ENOTTY:
		fmt_print_str(w, "L_ENOTTY");
		break;
	case LIB9P_ERRNO_L_ETXTBSY:
		fmt_print_str(w, "L_ETXTBSY");
		break;
	case LIB9P_ERRNO_L_EFBIG:
		fmt_print_str(w, "L_EFBIG");
		break;
	case LIB9P_ERRNO_L_ENOSPC:
		fmt_print_str(w, "L_ENOSPC");
		break;
	case LIB9P_ERRNO_L_ESPIPE:
		fmt_print_str(w, "L_ESPIPE");
		break;
	case LIB9P_ERRNO_L_EROFS:
		fmt_print_str(w, "L_EROFS");
		break;
	case LIB9P_ERRNO_L_EMLINK:
		fmt_print_str(w, "L_EMLINK");
		break;
	case LIB9P_ERRNO_L_EPIPE:
		fmt_print_str(w, "L_EPIPE");
		break;
	case LIB9P_ERRNO_L_EDOM:
		fmt_print_str(w, "L_EDOM");
		break;
	case LIB9P_ERRNO_L_ERANGE:
		fmt_print_str(w, "L_ERANGE");
		break;
	case LIB9P_ERRNO_L_EDEADLK:
		fmt_print_str(w, "L_EDEADLK");
		break;
	case LIB9P_ERRNO_L_ENAMETOOLONG:
		fmt_print_str(w, "L_ENAMETOOLONG");
		break;
	case LIB9P_ERRNO_L_ENOLCK:
		fmt_print_str(w, "L_ENOLCK");
		break;
	case LIB9P_ERRNO_L_ENOSYS:
		fmt_print_str(w, "L_ENOSYS");
		break;
	case LIB9P_ERRNO_L_ENOTEMPTY:
		fmt_print_str(w, "L_ENOTEMPTY");
		break;
	case LIB9P_ERRNO_L_ELOOP:
		fmt_print_str(w, "L_ELOOP");
		break;
	case LIB9P_ERRNO_L_ENOMSG:
		fmt_print_str(w, "L_ENOMSG");
		break;
	case LIB9P_ERRNO_L_EIDRM:
		fmt_print_str(w, "L_EIDRM");
		break;
	case LIB9P_ERRNO_L_ECHRNG:
		fmt_print_str(w, "L_ECHRNG");
		break;
	case LIB9P_ERRNO_L_EL2NSYNC:
		fmt_print_str(w, "L_EL2NSYNC");
		break;
	case LIB9P_ERRNO_L_EL3HLT:
		fmt_print_str(w, "L_EL3HLT");
		break;
	case LIB9P_ERRNO_L_EL3RST:
		fmt_print_str(w, "L_EL3RST");
		break;
	case LIB9P_ERRNO_L_ELNRNG:
		fmt_print_str(w, "L_ELNRNG");
		break;
	case LIB9P_ERRNO_L_EUNATCH:
		fmt_print_str(w, "L_EUNATCH");
		break;
	case LIB9P_ERRNO_L_ENOCSI:
		fmt_print_str(w, "L_ENOCSI");
		break;
	case LIB9P_ERRNO_L_EL2HLT:
		fmt_print_str(w, "L_EL2HLT");
		break;
	case LIB9P_ERRNO_L_EBADE:
		fmt_print_str(w, "L_EBADE");
		break;
	case LIB9P_ERRNO_L_EBADR:
		fmt_print_str(w, "L_EBADR");
		break;
	case LIB9P_ERRNO_L_EXFULL:
		fmt_print_str(w, "L_EXFULL");
		break;
	case LIB9P_ERRNO_L_ENOANO:
		fmt_print_str(w, "L_ENOANO");
		break;
	case LIB9P_ERRNO_L_EBADRQC:
		fmt_print_str(w, "L_EBADRQC");
		break;
	case LIB9P_ERRNO_L_EBADSLT:
		fmt_print_str(w, "L_EBADSLT");
		break;
	case LIB9P_ERRNO_L_EBFONT:
		fmt_print_str(w, "L_EBFONT");
		break;
	case LIB9P_ERRNO_L_ENOSTR:
		fmt_print_str(w, "L_ENOSTR");
		break;
	case LIB9P_ERRNO_L_ENODATA:
		fmt_print_str(w, "L_ENODATA");
		break;
	case LIB9P_ERRNO_L_ETIME:
		fmt_print_str(w, "L_ETIME");
		break;
	case LIB9P_ERRNO_L_ENOSR:
		fmt_print_str(w, "L_ENOSR");
		break;
	case LIB9P_ERRNO_L_ENONET:
		fmt_print_str(w, "L_ENONET");
		break;
	case LIB9P_ERRNO_L_ENOPKG:
		fmt_print_str(w, "L_ENOPKG");
		break;
	case LIB9P_ERRNO_L_EREMOTE:
		fmt_print_str(w, "L_EREMOTE");
		break;
	case LIB9P_ERRNO_L_ENOLINK:
		fmt_print_str(w, "L_ENOLINK");
		break;
	case LIB9P_ERRNO_L_EADV:
		fmt_print_str(w, "L_EADV");
		break;
	case LIB9P_ERRNO_L_ESRMNT:
		fmt_print_str(w, "L_ESRMNT");
		break;
	case LIB9P_ERRNO_L_ECOMM:
		fmt_print_str(w, "L_ECOMM");
		break;
	case LIB9P_ERRNO_L_EPROTO:
		fmt_print_str(w, "L_EPROTO");
		break;
	case LIB9P_ERRNO_L_EMULTIHOP:
		fmt_print_str(w, "L_EMULTIHOP");
		break;
	case LIB9P_ERRNO_L_EDOTDOT:
		fmt_print_str(w, "L_EDOTDOT");
		break;
	case LIB9P_ERRNO_L_EBADMSG:
		fmt_print_str(w, "L_EBADMSG");
		break;
	case LIB9P_ERRNO_L_EOVERFLOW:
		fmt_print_str(w, "L_EOVERFLOW");
		break;
	case LIB9P_ERRNO_L_ENOTUNIQ:
		fmt_print_str(w, "L_ENOTUNIQ");
		break;
	case LIB9P_ERRNO_L_EBADFD:
		fmt_print_str(w, "L_EBADFD");
		break;
	case LIB9P_ERRNO_L_EREMCHG:
		fmt_print_str(w, "L_EREMCHG");
		break;
	case LIB9P_ERRNO_L_ELIBACC:
		fmt_print_str(w, "L_ELIBACC");
		break;
	case LIB9P_ERRNO_L_ELIBBAD:
		fmt_print_str(w, "L_ELIBBAD");
		break;
	case LIB9P_ERRNO_L_ELIBSCN:
		fmt_print_str(w, "L_ELIBSCN");
		break;
	case LIB9P_ERRNO_L_ELIBMAX:
		fmt_print_str(w, "L_ELIBMAX");
		break;
	case LIB9P_ERRNO_L_ELIBEXEC:
		fmt_print_str(w, "L_ELIBEXEC");
		break;
	case LIB9P_ERRNO_L_EILSEQ:
		fmt_print_str(w, "L_EILSEQ");
		break;
	case LIB9P_ERRNO_L_ERESTART:
		fmt_print_str(w, "L_ERESTART");
		break;
	case LIB9P_ERRNO_L_ESTRPIPE:
		fmt_print_str(w, "L_ESTRPIPE");
		break;
	case LIB9P_ERRNO_L_EUSERS:
		fmt_print_str(w, "L_EUSERS");
		break;
	case LIB9P_ERRNO_L_ENOTSOCK:
		fmt_print_str(w, "L_ENOTSOCK");
		break;
	case LIB9P_ERRNO_L_EDESTADDRREQ:
		fmt_print_str(w, "L_EDESTADDRREQ");
		break;
	case LIB9P_ERRNO_L_EMSGSIZE:
		fmt_print_str(w, "L_EMSGSIZE");
		break;
	case LIB9P_ERRNO_L_EPROTOTYPE:
		fmt_print_str(w, "L_EPROTOTYPE");
		break;
	case LIB9P_ERRNO_L_ENOPROTOOPT:
		fmt_print_str(w, "L_ENOPROTOOPT");
		break;
	case LIB9P_ERRNO_L_EPROTONOSUPPORT:
		fmt_print_str(w, "L_EPROTONOSUPPORT");
		break;
	case LIB9P_ERRNO_L_ESOCKTNOSUPPORT:
		fmt_print_str(w, "L_ESOCKTNOSUPPORT");
		break;
	case LIB9P_ERRNO_L_EOPNOTSUPP:
		fmt_print_str(w, "L_EOPNOTSUPP");
		break;
	case LIB9P_ERRNO_L_EPFNOSUPPORT:
		fmt_print_str(w, "L_EPFNOSUPPORT");
		break;
	case LIB9P_ERRNO_L_EAFNOSUPPORT:
		fmt_print_str(w, "L_EAFNOSUPPORT");
		break;
	case LIB9P_ERRNO_L_EADDRINUSE:
		fmt_print_str(w, "L_EADDRINUSE");
		break;
	case LIB9P_ERRNO_L_EADDRNOTAVAIL:
		fmt_print_str(w, "L_EADDRNOTAVAIL");
		break;
	case LIB9P_ERRNO_L_ENETDOWN:
		fmt_print_str(w, "L_ENETDOWN");
		break;
	case LIB9P_ERRNO_L_ENETUNREACH:
		fmt_print_str(w, "L_ENETUNREACH");
		break;
	case LIB9P_ERRNO_L_ENETRESET:
		fmt_print_str(w, "L_ENETRESET");
		break;
	case LIB9P_ERRNO_L_ECONNABORTED:
		fmt_print_str(w, "L_ECONNABORTED");
		break;
	case LIB9P_ERRNO_L_ECONNRESET:
		fmt_print_str(w, "L_ECONNRESET");
		break;
	case LIB9P_ERRNO_L_ENOBUFS:
		fmt_print_str(w, "L_ENOBUFS");
		break;
	case LIB9P_ERRNO_L_EISCONN:
		fmt_print_str(w, "L_EISCONN");
		break;
	case LIB9P_ERRNO_L_ENOTCONN:
		fmt_print_str(w, "L_ENOTCONN");
		break;
	case LIB9P_ERRNO_L_ESHUTDOWN:
		fmt_print_str(w, "L_ESHUTDOWN");
		break;
	case LIB9P_ERRNO_L_ETOOMANYREFS:
		fmt_print_str(w, "L_ETOOMANYREFS");
		break;
	case LIB9P_ERRNO_L_ETIMEDOUT:
		fmt_print_str(w, "L_ETIMEDOUT");
		break;
	case LIB9P_ERRNO_L_ECONNREFUSED:
		fmt_print_str(w, "L_ECONNREFUSED");
		break;
	case LIB9P_ERRNO_L_EHOSTDOWN:
		fmt_print_str(w, "L_EHOSTDOWN");
		break;
	case LIB9P_ERRNO_L_EHOSTUNREACH:
		fmt_print_str(w, "L_EHOSTUNREACH");
		break;
	case LIB9P_ERRNO_L_EALREADY:
		fmt_print_str(w, "L_EALREADY");
		break;
	case LIB9P_ERRNO_L_EINPROGRESS:
		fmt_print_str(w, "L_EINPROGRESS");
		break;
	case LIB9P_ERRNO_L_ESTALE:
		fmt_print_str(w, "L_ESTALE");
		break;
	case LIB9P_ERRNO_L_EUCLEAN:
		fmt_print_str(w, "L_EUCLEAN");
		break;
	case LIB9P_ERRNO_L_ENOTNAM:
		fmt_print_str(w, "L_ENOTNAM");
		break;
	case LIB9P_ERRNO_L_ENAVAIL:
		fmt_print_str(w, "L_ENAVAIL");
		break;
	case LIB9P_ERRNO_L_EISNAM:
		fmt_print_str(w, "L_EISNAM");
		break;
	case LIB9P_ERRNO_L_EREMOTEIO:
		fmt_print_str(w, "L_EREMOTEIO");
		break;
	case LIB9P_ERRNO_L_EDQUOT:
		fmt_print_str(w, "L_EDQUOT");
		break;
	case LIB9P_ERRNO_L_ENOMEDIUM:
		fmt_print_str(w, "L_ENOMEDIUM");
		break;
	case LIB9P_ERRNO_L_EMEDIUMTYPE:
		fmt_print_str(w, "L_EMEDIUMTYPE");
		break;
	case LIB9P_ERRNO_L_ECANCELED:
		fmt_print_str(w, "L_ECANCELED");
		break;
	case LIB9P_ERRNO_L_ENOKEY:
		fmt_print_str(w, "L_ENOKEY");
		break;
	case LIB9P_ERRNO_L_EKEYEXPIRED:
		fmt_print_str(w, "L_EKEYEXPIRED");
		break;
	case LIB9P_ERRNO_L_EKEYREVOKED:
		fmt_print_str(w, "L_EKEYREVOKED");
		break;
	case LIB9P_ERRNO_L_EKEYREJECTED:
		fmt_print_str(w, "L_EKEYREJECTED");
		break;
	case LIB9P_ERRNO_L_EOWNERDEAD:
		fmt_print_str(w, "L_EOWNERDEAD");
		break;
	case LIB9P_ERRNO_L_ENOTRECOVERABLE:
		fmt_print_str(w, "L_ENOTRECOVERABLE");
		break;
	case LIB9P_ERRNO_L_ERFKILL:
		fmt_print_str(w, "L_ERFKILL");
		break;
	case LIB9P_ERRNO_L_EHWPOISON:
		fmt_print_str(w, "L_EHWPOISON");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_L
[[maybe_unused]] static void fmt_print_super_magic(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_super_magic_t *self) {
	switch (*self) {
	case LIB9P_SUPER_MAGIC_V9FS_MAGIC:
		fmt_print_str(w, "V9FS_MAGIC");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

[[maybe_unused]] static void fmt_print_lo(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_lo_t *self) {
	bool empty = true;
	fmt_print_byte(w, '(');
	if (*self & (UINT32_C(1)<<31)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<31");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<30)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<30");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<29)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<29");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<28)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<28");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<27)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<27");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<26)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<26");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<25)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<25");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<24)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<24");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<23)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<23");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<22)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<22");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<21)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<21");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<20)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "SYNC");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<19)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "CLOEXEC");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<18)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "NOATIME");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<17)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "NOFOLLOW");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<16)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "DIRECTORY");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<15)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "LARGEFILE");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<14)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "DIRECT");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<13)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "BSD_FASYNC");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<12)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "DSYNC");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<11)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "NONBLOCK");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<10)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "APPEND");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<9)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "TRUNC");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<8)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "NOCTTY");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<7)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "EXCL");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<6)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "CREATE");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<5)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<5");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<4)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<4");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<3)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<3");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<2)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<2");
		empty = false;
	}
	switch (*self & LIB9P_LO_MODE_MASK) {
	case LIB9P_LO_MODE_RDONLY:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE_RDONLY");
		empty = false;
		break;
	case LIB9P_LO_MODE_WRONLY:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE_WRONLY");
		empty = false;
		break;
	case LIB9P_LO_MODE_RDWR:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE_RDWR");
		empty = false;
		break;
	case LIB9P_LO_MODE_NOACCESS:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE_NOACCESS");
		empty = false;
		break;
	default:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_base10(w, *self & LIB9P_LO_MODE_MASK);
		empty = false;
	}
	if (empty)
		fmt_print_byte(w, '0');
	fmt_print_byte(w, ')');
}

[[maybe_unused]] static void fmt_print_dt(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_dt_t *self) {
	switch (*self) {
	case LIB9P_DT_UNKNOWN:
		fmt_print_str(w, "UNKNOWN");
		break;
	case LIB9P_DT_PIPE:
		fmt_print_str(w, "PIPE");
		break;
	case LIB9P_DT_CHAR_DEV:
		fmt_print_str(w, "CHAR_DEV");
		break;
	case LIB9P_DT_DIRECTORY:
		fmt_print_str(w, "DIRECTORY");
		break;
	case LIB9P_DT_BLOCK_DEV:
		fmt_print_str(w, "BLOCK_DEV");
		break;
	case LIB9P_DT_REGULAR:
		fmt_print_str(w, "REGULAR");
		break;
	case LIB9P_DT_SYMLINK:
		fmt_print_str(w, "SYMLINK");
		break;
	case LIB9P_DT_SOCKET:
		fmt_print_str(w, "SOCKET");
		break;
	case _LIB9P_DT_WHITEOUT:
		fmt_print_str(w, "_WHITEOUT");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

[[maybe_unused]] static void fmt_print_mode(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_mode_t *self) {
	bool empty = true;
	fmt_print_byte(w, '(');
	if (*self & (UINT32_C(1)<<31)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<31");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<30)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<30");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<29)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<29");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<28)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<28");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<27)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<27");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<26)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<26");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<25)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<25");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<24)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<24");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<23)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<23");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<22)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<22");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<21)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<21");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<20)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<20");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<19)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<19");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<18)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<18");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<17)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<17");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<16)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<16");
		empty = false;
	}
	switch (*self & LIB9P_MODE_FMT_MASK) {
	case LIB9P_MODE_FMT_PIPE:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "FMT_PIPE");
		empty = false;
		break;
	case LIB9P_MODE_FMT_CHAR_DEV:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "FMT_CHAR_DEV");
		empty = false;
		break;
	case LIB9P_MODE_FMT_DIRECTORY:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "FMT_DIRECTORY");
		empty = false;
		break;
	case LIB9P_MODE_FMT_BLOCK_DEV:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "FMT_BLOCK_DEV");
		empty = false;
		break;
	case LIB9P_MODE_FMT_REGULAR:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "FMT_REGULAR");
		empty = false;
		break;
	case LIB9P_MODE_FMT_SYMLINK:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "FMT_SYMLINK");
		empty = false;
		break;
	case LIB9P_MODE_FMT_SOCKET:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "FMT_SOCKET");
		empty = false;
		break;
	default:
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_base10(w, *self & LIB9P_MODE_FMT_MASK);
		empty = false;
	}
	if (*self & (UINT32_C(1)<<11)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_SETGROUP");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<10)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_SETUSER");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<9)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_STICKY");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<8)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_OWNER_R");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<7)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_OWNER_W");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<6)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_OWNER_X");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<5)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_GROUP_R");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<4)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_GROUP_W");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<3)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_GROUP_X");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<2)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_OTHER_R");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<1)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_OTHER_W");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<0)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "PERM_OTHER_X");
		empty = false;
	}
	if (empty)
		fmt_print_byte(w, '0');
	fmt_print_byte(w, ')');
}

[[maybe_unused]] static void fmt_print_b4(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_b4_t *self) {
	switch (*self) {
	case LIB9P_B4_FALSE:
		fmt_print_str(w, "FALSE");
		break;
	case LIB9P_B4_TRUE:
		fmt_print_str(w, "TRUE");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

[[maybe_unused]] static void fmt_print_getattr(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_getattr_t *self) {
	bool empty = true;
	fmt_print_byte(w, '(');
	if (*self & (UINT64_C(1)<<63)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<63");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<62)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<62");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<61)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<61");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<60)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<60");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<59)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<59");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<58)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<58");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<57)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<57");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<56)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<56");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<55)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<55");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<54)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<54");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<53)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<53");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<52)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<52");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<51)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<51");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<50)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<50");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<49)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<49");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<48)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<48");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<47)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<47");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<46)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<46");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<45)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<45");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<44)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<44");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<43)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<43");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<42)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<42");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<41)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<41");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<40)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<40");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<39)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<39");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<38)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<38");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<37)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<37");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<36)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<36");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<35)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<35");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<34)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<34");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<33)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<33");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<32)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<32");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<31)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<31");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<30)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<30");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<29)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<29");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<28)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<28");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<27)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<27");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<26)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<26");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<25)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<25");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<24)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<24");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<23)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<23");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<22)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<22");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<21)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<21");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<20)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<20");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<19)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<19");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<18)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<18");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<17)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<17");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<16)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<16");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<15)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<15");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<14)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<14");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<13)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "DATA_VERSION");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<12)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "GEN");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<11)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "BTIME");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<10)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "BLOCKS");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<9)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "SIZE");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<8)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "INO");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<7)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "CTIME");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<6)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MTIME");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<5)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "ATIME");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<4)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "RDEV");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<3)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "GID");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<2)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "UID");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<1)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "NLINK");
		empty = false;
	}
	if (*self & (UINT64_C(1)<<0)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE");
		empty = false;
	}
	if (empty)
		fmt_print_byte(w, '0');
	fmt_print_byte(w, ')');
}

[[maybe_unused]] static void fmt_print_setattr(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_setattr_t *self) {
	bool empty = true;
	fmt_print_byte(w, '(');
	if (*self & (UINT32_C(1)<<31)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<31");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<30)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<30");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<29)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<29");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<28)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<28");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<27)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<27");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<26)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<26");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<25)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<25");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<24)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<24");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<23)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<23");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<22)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<22");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<21)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<21");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<20)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<20");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<19)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<19");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<18)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<18");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<17)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<17");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<16)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<16");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<15)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<15");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<14)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<14");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<13)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<13");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<12)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<12");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<11)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<11");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<10)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<10");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<9)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<9");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<8)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MTIME_SET");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<7)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "ATIME_SET");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<6)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "CTIME");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<5)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MTIME");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<4)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "ATIME");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<3)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "SIZE");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<2)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "GID");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<1)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "UID");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<0)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "MODE");
		empty = false;
	}
	if (empty)
		fmt_print_byte(w, '0');
	fmt_print_byte(w, ')');
}

[[maybe_unused]] static void fmt_print_lock_type(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_lock_type_t *self) {
	switch (*self) {
	case LIB9P_LOCK_TYPE_RDLCK:
		fmt_print_str(w, "RDLCK");
		break;
	case LIB9P_LOCK_TYPE_WRLCK:
		fmt_print_str(w, "WRLCK");
		break;
	case LIB9P_LOCK_TYPE_UNLCK:
		fmt_print_str(w, "UNLCK");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

[[maybe_unused]] static void fmt_print_lock_flags(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_lock_flags_t *self) {
	bool empty = true;
	fmt_print_byte(w, '(');
	if (*self & (UINT32_C(1)<<31)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<31");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<30)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<30");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<29)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<29");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<28)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<28");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<27)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<27");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<26)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<26");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<25)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<25");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<24)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<24");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<23)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<23");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<22)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<22");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<21)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<21");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<20)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<20");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<19)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<19");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<18)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<18");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<17)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<17");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<16)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<16");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<15)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<15");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<14)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<14");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<13)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<13");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<12)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<12");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<11)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<11");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<10)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<10");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<9)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<9");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<8)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<8");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<7)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<7");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<6)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<6");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<5)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<5");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<4)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<4");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<3)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<3");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<2)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "1<<2");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<1)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "RECLAIM");
		empty = false;
	}
	if (*self & (UINT32_C(1)<<0)) {
		if (!empty)
			fmt_print_byte(w, '|');
		fmt_print_str(w, "BLOCK");
		empty = false;
	}
	if (empty)
		fmt_print_byte(w, '0');
	fmt_print_byte(w, ')');
}

[[maybe_unused]] static void fmt_print_lock_status(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, lib9p_lock_status_t *self) {
	switch (*self) {
	case LIB9P_LOCK_STATUS_SUCCESS:
		fmt_print_str(w, "SUCCESS");
		break;
	case LIB9P_LOCK_STATUS_BLOCKED:
		fmt_print_str(w, "BLOCKED");
		break;
	case LIB9P_LOCK_STATUS_ERROR:
		fmt_print_str(w, "ERROR");
		break;
	case LIB9P_LOCK_STATUS_GRACE:
		fmt_print_str(w, "GRACE");
		break;
	default:
		fmt_print_base10(w, *self);
	}
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
[[maybe_unused]] static void fmt_print_s(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_s *self) {
	fmt_print_qmem(w, self->utf8, self->len);
}

[[maybe_unused]] static void fmt_print_qid(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_qid *self) {
	fmt_print_byte(w, '{');
	fmt_print_str(w, " type=");
	fmt_print_qt(w, ctx, &self->type);
	fmt_print_str(w, " vers=");
	fmt_print_base10(w, self->vers);
	fmt_print_str(w, " path=");
	fmt_print_base10(w, self->path);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_Tflush(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tflush *self) {
	fmt_print_str(w, "Tflush {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " oldtag=");
	fmt_print_base10(w, self->oldtag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rflush(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rflush *self) {
	fmt_print_str(w, "Rflush {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_Topen(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Topen *self) {
	fmt_print_str(w, "Topen {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " mode=");
	fmt_print_o(w, ctx, &self->mode);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_Tread(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tread *self) {
	fmt_print_str(w, "Tread {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " offset=");
	fmt_print_base10(w, self->offset);
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rread(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rread *self) {
	fmt_print_str(w, "Rread {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	if (is_valid_utf8_without_nul((uint8_t *)self->data, (size_t)self->count)) {
		fmt_print_str(w, " data=");
		fmt_print_qmem(w, self->data, self->count < 50 ? self->count : 50);
		if (self->count > 50)
			fmt_print_str(w, "...");
	} else {
		fmt_print_str(w, " data=<bytedata>");
	}
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Twrite(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Twrite *self) {
	fmt_print_str(w, "Twrite {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " offset=");
	fmt_print_base10(w, self->offset);
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	if (is_valid_utf8_without_nul((uint8_t *)self->data, (size_t)self->count)) {
		fmt_print_str(w, " data=");
		fmt_print_qmem(w, self->data, self->count < 50 ? self->count : 50);
		if (self->count > 50)
			fmt_print_str(w, "...");
	} else {
		fmt_print_str(w, " data=<bytedata>");
	}
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rwrite(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rwrite *self) {
	fmt_print_str(w, "Rwrite {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tclunk(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tclunk *self) {
	fmt_print_str(w, "Tclunk {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rclunk(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rclunk *self) {
	fmt_print_str(w, "Rclunk {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tremove(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tremove *self) {
	fmt_print_str(w, "Tremove {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rremove(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rremove *self) {
	fmt_print_str(w, "Rremove {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_Tstat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tstat *self) {
	fmt_print_str(w, "Tstat {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rwstat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rwstat *self) {
	fmt_print_str(w, "Rwstat {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_p9p
[[maybe_unused]] static void fmt_print_Topenfd(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Topenfd *self) {
	fmt_print_str(w, "Topenfd {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " mode=");
	fmt_print_o(w, ctx, &self->mode);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_L
[[maybe_unused]] static void fmt_print_Rlerror(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rlerror *self) {
	fmt_print_str(w, "Rlerror {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " errnum=");
	fmt_print_errno(w, ctx, &self->errnum);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tstatfs(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tstatfs *self) {
	fmt_print_str(w, "Tstatfs {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rstatfs(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rstatfs *self) {
	fmt_print_str(w, "Rstatfs {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " type=");
	fmt_print_super_magic(w, ctx, &self->type);
	fmt_print_str(w, " bsize=");
	fmt_print_base10(w, self->bsize);
	fmt_print_str(w, " blocks=");
	fmt_print_base10(w, self->blocks);
	fmt_print_str(w, " bfree=");
	fmt_print_base10(w, self->bfree);
	fmt_print_str(w, " bavail=");
	fmt_print_base10(w, self->bavail);
	fmt_print_str(w, " files=");
	fmt_print_base10(w, self->files);
	fmt_print_str(w, " ffree=");
	fmt_print_base10(w, self->ffree);
	fmt_print_str(w, " fsid=");
	fmt_print_base10(w, self->fsid);
	fmt_print_str(w, " namelen=");
	fmt_print_base10(w, self->namelen);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tlopen(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tlopen *self) {
	fmt_print_str(w, "Tlopen {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " flags=");
	fmt_print_lo(w, ctx, &self->flags);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rrename(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rrename *self) {
	fmt_print_str(w, "Rrename {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Treadlink(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Treadlink *self) {
	fmt_print_str(w, "Treadlink {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tgetattr(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tgetattr *self) {
	fmt_print_str(w, "Tgetattr {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " request_mask=");
	fmt_print_getattr(w, ctx, &self->request_mask);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tsetattr(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tsetattr *self) {
	fmt_print_str(w, "Tsetattr {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " valid=");
	fmt_print_setattr(w, ctx, &self->valid);
	fmt_print_str(w, " mode=");
	fmt_print_mode(w, ctx, &self->mode);
	fmt_print_str(w, " uid=");
	fmt_print_nuid(w, ctx, &self->uid);
	fmt_print_str(w, " gid=");
	fmt_print_nuid(w, ctx, &self->gid);
	fmt_print_str(w, " filesize=");
	fmt_print_base10(w, self->filesize);
	fmt_print_str(w, " atime_sec=");
	fmt_print_base10(w, self->atime_sec);
	fmt_print_str(w, " atime_nsec=");
	fmt_print_base10(w, self->atime_nsec);
	fmt_print_str(w, " mtime_sec=");
	fmt_print_base10(w, self->mtime_sec);
	fmt_print_str(w, " mtime_nsec=");
	fmt_print_base10(w, self->mtime_nsec);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rsetattr(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rsetattr *self) {
	fmt_print_str(w, "Rsetattr {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rxattrwalk(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rxattrwalk *self) {
	fmt_print_str(w, "Rxattrwalk {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " attr_size=");
	fmt_print_base10(w, self->attr_size);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rxattrcreate(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rxattrcreate *self) {
	fmt_print_str(w, "Rxattrcreate {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Treaddir(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Treaddir *self) {
	fmt_print_str(w, "Treaddir {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " offset=");
	fmt_print_base10(w, self->offset);
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rreaddir(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rreaddir *self) {
	fmt_print_str(w, "Rreaddir {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	if (is_valid_utf8_without_nul((uint8_t *)self->data, (size_t)self->count)) {
		fmt_print_str(w, " data=");
		fmt_print_qmem(w, self->data, self->count < 50 ? self->count : 50);
		if (self->count > 50)
			fmt_print_str(w, "...");
	} else {
		fmt_print_str(w, " data=<bytedata>");
	}
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tfsync(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tfsync *self) {
	fmt_print_str(w, "Tfsync {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " datasync=");
	fmt_print_b4(w, ctx, &self->datasync);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rfsync(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rfsync *self) {
	fmt_print_str(w, "Rfsync {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rlock(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rlock *self) {
	fmt_print_str(w, "Rlock {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " status=");
	fmt_print_lock_status(w, ctx, &self->status);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rlink(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rlink *self) {
	fmt_print_str(w, "Rlink {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rrenameat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rrenameat *self) {
	fmt_print_str(w, "Rrenameat {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Runlinkat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Runlinkat *self) {
	fmt_print_str(w, "Runlinkat {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
[[maybe_unused]] static void fmt_print_Tsession(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tsession *self) {
	fmt_print_str(w, "Tsession {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " key=");
	fmt_print_base10(w, self->key);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rsession(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rsession *self) {
	fmt_print_str(w, "Rsession {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rsread(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rsread *self) {
	fmt_print_str(w, "Rsread {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	if (is_valid_utf8_without_nul((uint8_t *)self->data, (size_t)self->count)) {
		fmt_print_str(w, " data=");
		fmt_print_qmem(w, self->data, self->count < 50 ? self->count : 50);
		if (self->count > 50)
			fmt_print_str(w, "...");
	} else {
		fmt_print_str(w, " data=<bytedata>");
	}
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rswrite(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rswrite *self) {
	fmt_print_str(w, "Rswrite {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] void fmt_print_stat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_stat *self) {
	fmt_print_byte(w, '{');
	fmt_print_str(w, " fstype=");
	fmt_print_base10(w, self->fstype);
	fmt_print_str(w, " fsdev=");
	fmt_print_base10(w, self->fsdev);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " mode=");
	fmt_print_dm(w, ctx, &self->mode);
	fmt_print_str(w, " atime=");
	fmt_print_base10(w, self->atime);
	fmt_print_str(w, " mtime=");
	fmt_print_base10(w, self->mtime);
	fmt_print_str(w, " length=");
	fmt_print_base10(w, self->length);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " owner_uname=");
	fmt_print_s(w, ctx, &self->owner_uname);
	fmt_print_str(w, " owner_gname=");
	fmt_print_s(w, ctx, &self->owner_gname);
	fmt_print_str(w, " last_modifier_uname=");
	fmt_print_s(w, ctx, &self->last_modifier_uname);
#if CONFIG_9P_ENABLE_9P2000_u
	fmt_print_str(w, " extension=");
	fmt_print_s(w, ctx, &self->extension);
	fmt_print_str(w, " owner_unum=");
	fmt_print_nuid(w, ctx, &self->owner_unum);
	fmt_print_str(w, " owner_gnum=");
	fmt_print_nuid(w, ctx, &self->owner_gnum);
	fmt_print_str(w, " last_modifier_unum=");
	fmt_print_nuid(w, ctx, &self->last_modifier_unum);
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
[[maybe_unused]] static void fmt_print_Tversion(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tversion *self) {
	fmt_print_str(w, "Tversion {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " max_msg_size=");
	fmt_print_base10(w, self->max_msg_size);
	fmt_print_str(w, " version=");
	fmt_print_s(w, ctx, &self->version);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rversion(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rversion *self) {
	fmt_print_str(w, "Rversion {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " max_msg_size=");
	fmt_print_base10(w, self->max_msg_size);
	fmt_print_str(w, " version=");
	fmt_print_s(w, ctx, &self->version);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_Tauth(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tauth *self) {
	fmt_print_str(w, "Tauth {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " afid=");
	fmt_print_fid(w, ctx, &self->afid);
	fmt_print_str(w, " uname=");
	fmt_print_s(w, ctx, &self->uname);
	fmt_print_str(w, " aname=");
	fmt_print_s(w, ctx, &self->aname);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	fmt_print_str(w, " unum=");
	fmt_print_nuid(w, ctx, &self->unum);
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rauth(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rauth *self) {
	fmt_print_str(w, "Rauth {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " aqid=");
	fmt_print_qid(w, ctx, &self->aqid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tattach(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tattach *self) {
	fmt_print_str(w, "Tattach {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " afid=");
	fmt_print_fid(w, ctx, &self->afid);
	fmt_print_str(w, " uname=");
	fmt_print_s(w, ctx, &self->uname);
	fmt_print_str(w, " aname=");
	fmt_print_s(w, ctx, &self->aname);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	fmt_print_str(w, " unum=");
	fmt_print_nuid(w, ctx, &self->unum);
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rattach(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rattach *self) {
	fmt_print_str(w, "Rattach {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized
[[maybe_unused]] static void fmt_print_Rerror(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rerror *self) {
	fmt_print_str(w, "Rerror {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " errstr=");
	fmt_print_s(w, ctx, &self->errstr);
#if CONFIG_9P_ENABLE_9P2000_u
	fmt_print_str(w, " errnum=");
	fmt_print_errno(w, ctx, &self->errnum);
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u || CONFIG_9P_ENABLE_uninitialized */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_Twalk(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Twalk *self) {
	fmt_print_str(w, "Twalk {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " newfid=");
	fmt_print_fid(w, ctx, &self->newfid);
	fmt_print_str(w, " nwname=");
	fmt_print_base10(w, self->nwname);
	fmt_print_str(w, " wname=[");
	for (uint16_t i = 0; i < self->nwname; i++) {
		if (i)
			fmt_print_byte(w, ',');
		fmt_print_byte(w, ' ');
		fmt_print_s(w, ctx, &self->wname[i]);
	}
	fmt_print_str(w, " ]");
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rwalk(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rwalk *self) {
	fmt_print_str(w, "Rwalk {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " nwqid=");
	fmt_print_base10(w, self->nwqid);
	fmt_print_str(w, " wqid=[");
	for (uint16_t i = 0; i < self->nwqid; i++) {
		if (i)
			fmt_print_byte(w, ',');
		fmt_print_byte(w, ' ');
		fmt_print_qid(w, ctx, &self->wqid[i]);
	}
	fmt_print_str(w, " ]");
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_Ropen(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Ropen *self) {
	fmt_print_str(w, "Ropen {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " iounit=");
	fmt_print_base10(w, self->iounit);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tcreate(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tcreate *self) {
	fmt_print_str(w, "Tcreate {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " perm=");
	fmt_print_dm(w, ctx, &self->perm);
	fmt_print_str(w, " mode=");
	fmt_print_o(w, ctx, &self->mode);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rcreate(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rcreate *self) {
	fmt_print_str(w, "Rcreate {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " iounit=");
	fmt_print_base10(w, self->iounit);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_p9p
[[maybe_unused]] static void fmt_print_Ropenfd(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Ropenfd *self) {
	fmt_print_str(w, "Ropenfd {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " iounit=");
	fmt_print_base10(w, self->iounit);
	fmt_print_str(w, " unixfd=");
	fmt_print_base10(w, self->unixfd);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_L
[[maybe_unused]] static void fmt_print_Rlopen(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rlopen *self) {
	fmt_print_str(w, "Rlopen {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " iounit=");
	fmt_print_base10(w, self->iounit);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tlcreate(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tlcreate *self) {
	fmt_print_str(w, "Tlcreate {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " flags=");
	fmt_print_lo(w, ctx, &self->flags);
	fmt_print_str(w, " mode=");
	fmt_print_mode(w, ctx, &self->mode);
	fmt_print_str(w, " gid=");
	fmt_print_nuid(w, ctx, &self->gid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rlcreate(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rlcreate *self) {
	fmt_print_str(w, "Rlcreate {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " iounit=");
	fmt_print_base10(w, self->iounit);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tsymlink(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tsymlink *self) {
	fmt_print_str(w, "Tsymlink {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " symtgt=");
	fmt_print_s(w, ctx, &self->symtgt);
	fmt_print_str(w, " gid=");
	fmt_print_nuid(w, ctx, &self->gid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rsymlink(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rsymlink *self) {
	fmt_print_str(w, "Rsymlink {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tmknod(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tmknod *self) {
	fmt_print_str(w, "Tmknod {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " dfid=");
	fmt_print_fid(w, ctx, &self->dfid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " mode=");
	fmt_print_mode(w, ctx, &self->mode);
	fmt_print_str(w, " major=");
	fmt_print_base10(w, self->major);
	fmt_print_str(w, " minor=");
	fmt_print_base10(w, self->minor);
	fmt_print_str(w, " gid=");
	fmt_print_nuid(w, ctx, &self->gid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rmknod(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rmknod *self) {
	fmt_print_str(w, "Rmknod {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Trename(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Trename *self) {
	fmt_print_str(w, "Trename {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " dfid=");
	fmt_print_fid(w, ctx, &self->dfid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rreadlink(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rreadlink *self) {
	fmt_print_str(w, "Rreadlink {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " target=");
	fmt_print_s(w, ctx, &self->target);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rgetattr(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rgetattr *self) {
	fmt_print_str(w, "Rgetattr {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " valid=");
	fmt_print_getattr(w, ctx, &self->valid);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " mode=");
	fmt_print_mode(w, ctx, &self->mode);
	fmt_print_str(w, " uid=");
	fmt_print_nuid(w, ctx, &self->uid);
	fmt_print_str(w, " gid=");
	fmt_print_nuid(w, ctx, &self->gid);
	fmt_print_str(w, " nlink=");
	fmt_print_base10(w, self->nlink);
	fmt_print_str(w, " rdev=");
	fmt_print_base10(w, self->rdev);
	fmt_print_str(w, " filesize=");
	fmt_print_base10(w, self->filesize);
	fmt_print_str(w, " blksize=");
	fmt_print_base10(w, self->blksize);
	fmt_print_str(w, " blocks=");
	fmt_print_base10(w, self->blocks);
	fmt_print_str(w, " atime_sec=");
	fmt_print_base10(w, self->atime_sec);
	fmt_print_str(w, " atime_nsec=");
	fmt_print_base10(w, self->atime_nsec);
	fmt_print_str(w, " mtime_sec=");
	fmt_print_base10(w, self->mtime_sec);
	fmt_print_str(w, " mtime_nsec=");
	fmt_print_base10(w, self->mtime_nsec);
	fmt_print_str(w, " ctime_sec=");
	fmt_print_base10(w, self->ctime_sec);
	fmt_print_str(w, " ctime_nsec=");
	fmt_print_base10(w, self->ctime_nsec);
	fmt_print_str(w, " btime_sec=");
	fmt_print_base10(w, self->btime_sec);
	fmt_print_str(w, " btime_nsec=");
	fmt_print_base10(w, self->btime_nsec);
	fmt_print_str(w, " gen=");
	fmt_print_base10(w, self->gen);
	fmt_print_str(w, " data_version=");
	fmt_print_base10(w, self->data_version);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Txattrwalk(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Txattrwalk *self) {
	fmt_print_str(w, "Txattrwalk {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " newfid=");
	fmt_print_fid(w, ctx, &self->newfid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Txattrcreate(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Txattrcreate *self) {
	fmt_print_str(w, "Txattrcreate {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " attr_size=");
	fmt_print_base10(w, self->attr_size);
	fmt_print_str(w, " flags=");
	fmt_print_base10(w, self->flags);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tlock(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tlock *self) {
	fmt_print_str(w, "Tlock {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " type=");
	fmt_print_lock_type(w, ctx, &self->type);
	fmt_print_str(w, " flags=");
	fmt_print_lock_flags(w, ctx, &self->flags);
	fmt_print_str(w, " start=");
	fmt_print_base10(w, self->start);
	fmt_print_str(w, " length=");
	fmt_print_base10(w, self->length);
	fmt_print_str(w, " proc_id=");
	fmt_print_base10(w, self->proc_id);
	fmt_print_str(w, " client_id=");
	fmt_print_s(w, ctx, &self->client_id);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tgetlock(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tgetlock *self) {
	fmt_print_str(w, "Tgetlock {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " type=");
	fmt_print_lock_type(w, ctx, &self->type);
	fmt_print_str(w, " start=");
	fmt_print_base10(w, self->start);
	fmt_print_str(w, " length=");
	fmt_print_base10(w, self->length);
	fmt_print_str(w, " proc_id=");
	fmt_print_base10(w, self->proc_id);
	fmt_print_str(w, " client_id=");
	fmt_print_s(w, ctx, &self->client_id);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rgetlock(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rgetlock *self) {
	fmt_print_str(w, "Rgetlock {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " type=");
	fmt_print_lock_type(w, ctx, &self->type);
	fmt_print_str(w, " start=");
	fmt_print_base10(w, self->start);
	fmt_print_str(w, " length=");
	fmt_print_base10(w, self->length);
	fmt_print_str(w, " proc_id=");
	fmt_print_base10(w, self->proc_id);
	fmt_print_str(w, " client_id=");
	fmt_print_s(w, ctx, &self->client_id);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tlink(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tlink *self) {
	fmt_print_str(w, "Tlink {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " dfid=");
	fmt_print_fid(w, ctx, &self->dfid);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tmkdir(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tmkdir *self) {
	fmt_print_str(w, "Tmkdir {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " dfid=");
	fmt_print_fid(w, ctx, &self->dfid);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " mode=");
	fmt_print_mode(w, ctx, &self->mode);
	fmt_print_str(w, " gid=");
	fmt_print_nuid(w, ctx, &self->gid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Rmkdir(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rmkdir *self) {
	fmt_print_str(w, "Rmkdir {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " qid=");
	fmt_print_qid(w, ctx, &self->qid);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Trenameat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Trenameat *self) {
	fmt_print_str(w, "Trenameat {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " olddirfid=");
	fmt_print_fid(w, ctx, &self->olddirfid);
	fmt_print_str(w, " oldname=");
	fmt_print_s(w, ctx, &self->oldname);
	fmt_print_str(w, " newdirfid=");
	fmt_print_fid(w, ctx, &self->newdirfid);
	fmt_print_str(w, " newname=");
	fmt_print_s(w, ctx, &self->newname);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tunlinkat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tunlinkat *self) {
	fmt_print_str(w, "Tunlinkat {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " dirfd=");
	fmt_print_fid(w, ctx, &self->dirfd);
	fmt_print_str(w, " name=");
	fmt_print_s(w, ctx, &self->name);
	fmt_print_str(w, " flags=");
	fmt_print_base10(w, self->flags);
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
[[maybe_unused]] static void fmt_print_Tsread(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tsread *self) {
	fmt_print_str(w, "Tsread {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_base10(w, self->fid);
	fmt_print_str(w, " nwname=");
	fmt_print_base10(w, self->nwname);
	fmt_print_str(w, " wname=[");
	for (uint16_t i = 0; i < self->nwname; i++) {
		if (i)
			fmt_print_byte(w, ',');
		fmt_print_byte(w, ' ');
		fmt_print_s(w, ctx, &self->wname[i]);
	}
	fmt_print_str(w, " ]");
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Tswrite(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Tswrite *self) {
	fmt_print_str(w, "Tswrite {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_base10(w, self->fid);
	fmt_print_str(w, " nwname=");
	fmt_print_base10(w, self->nwname);
	fmt_print_str(w, " wname=[");
	for (uint16_t i = 0; i < self->nwname; i++) {
		if (i)
			fmt_print_byte(w, ',');
		fmt_print_byte(w, ' ');
		fmt_print_s(w, ctx, &self->wname[i]);
	}
	fmt_print_str(w, " ]");
	fmt_print_str(w, " count=");
	fmt_print_base10(w, self->count);
	if (is_valid_utf8_without_nul((uint8_t *)self->data, (size_t)self->count)) {
		fmt_print_str(w, " data=");
		fmt_print_qmem(w, self->data, self->count < 50 ? self->count : 50);
		if (self->count > 50)
			fmt_print_str(w, "...");
	} else {
		fmt_print_str(w, " data=<bytedata>");
	}
	fmt_print_str(w, " }");
}

#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
[[maybe_unused]] static void fmt_print_Rstat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Rstat *self) {
	fmt_print_str(w, "Rstat {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " stat=");
	fmt_print_stat(w, ctx, &self->stat);
	fmt_print_str(w, " }");
}

[[maybe_unused]] static void fmt_print_Twstat(lo_interface fmt_dest w, [[maybe_unused]] struct lib9p_ctx *ctx, struct lib9p_msg_Twstat *self) {
	fmt_print_str(w, "Twstat {");
	fmt_print_str(w, " tag=");
	fmt_print_tag(w, ctx, &self->tag);
	fmt_print_str(w, " fid=");
	fmt_print_fid(w, ctx, &self->fid);
	fmt_print_str(w, " stat=");
	fmt_print_stat(w, ctx, &self->stat);
	fmt_print_str(w, " }");
}
#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */

/* tables.h *******************************************************************/

const struct _lib9p_ver_tentry _lib9p_table_ver[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {.name="9P2000", .min_Rerror_size=9, .min_Rread_size=11},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {.name="9P2000.L", .min_Rerror_size=11, .min_Rread_size=11},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {.name="9P2000.e", .min_Rerror_size=9, .min_Rread_size=11},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {.name="9P2000.p9p", .min_Rerror_size=9, .min_Rread_size=11},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {.name="9P2000.u", .min_Rerror_size=13, .min_Rread_size=11},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = {.name="uninitialized", .min_Rerror_size=9, .min_Rread_size=0},
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

#define _MSG(typ) [LIB9P_TYP_##typ] = {                \
		.name  = #typ,                         \
		.print = (_print_fn_t)fmt_print_##typ, \
	}
const struct _lib9p_msg_tentry _lib9p_table_msg[LIB9P_VER_NUM][0x100] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG(Tversion),
		_MSG(Rversion),
		_MSG(Tauth),
		_MSG(Rauth),
		_MSG(Tattach),
		_MSG(Rattach),
		_MSG(Rerror),
		_MSG(Tflush),
		_MSG(Rflush),
		_MSG(Twalk),
		_MSG(Rwalk),
		_MSG(Topen),
		_MSG(Ropen),
		_MSG(Tcreate),
		_MSG(Rcreate),
		_MSG(Tread),
		_MSG(Rread),
		_MSG(Twrite),
		_MSG(Rwrite),
		_MSG(Tclunk),
		_MSG(Rclunk),
		_MSG(Tremove),
		_MSG(Rremove),
		_MSG(Tstat),
		_MSG(Rstat),
		_MSG(Twstat),
		_MSG(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG(Rlerror),
		_MSG(Tstatfs),
		_MSG(Rstatfs),
		_MSG(Tlopen),
		_MSG(Rlopen),
		_MSG(Tlcreate),
		_MSG(Rlcreate),
		_MSG(Tsymlink),
		_MSG(Rsymlink),
		_MSG(Tmknod),
		_MSG(Rmknod),
		_MSG(Trename),
		_MSG(Rrename),
		_MSG(Treadlink),
		_MSG(Rreadlink),
		_MSG(Tgetattr),
		_MSG(Rgetattr),
		_MSG(Tsetattr),
		_MSG(Rsetattr),
		_MSG(Txattrwalk),
		_MSG(Rxattrwalk),
		_MSG(Txattrcreate),
		_MSG(Rxattrcreate),
		_MSG(Treaddir),
		_MSG(Rreaddir),
		_MSG(Tfsync),
		_MSG(Rfsync),
		_MSG(Tlock),
		_MSG(Rlock),
		_MSG(Tgetlock),
		_MSG(Rgetlock),
		_MSG(Tlink),
		_MSG(Rlink),
		_MSG(Tmkdir),
		_MSG(Rmkdir),
		_MSG(Trenameat),
		_MSG(Rrenameat),
		_MSG(Tunlinkat),
		_MSG(Runlinkat),
		_MSG(Tversion),
		_MSG(Rversion),
		_MSG(Tauth),
		_MSG(Rauth),
		_MSG(Tattach),
		_MSG(Rattach),
		_MSG(Tflush),
		_MSG(Rflush),
		_MSG(Twalk),
		_MSG(Rwalk),
		_MSG(Tread),
		_MSG(Rread),
		_MSG(Twrite),
		_MSG(Rwrite),
		_MSG(Tclunk),
		_MSG(Rclunk),
		_MSG(Tremove),
		_MSG(Rremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG(Tversion),
		_MSG(Rversion),
		_MSG(Tauth),
		_MSG(Rauth),
		_MSG(Tattach),
		_MSG(Rattach),
		_MSG(Rerror),
		_MSG(Tflush),
		_MSG(Rflush),
		_MSG(Twalk),
		_MSG(Rwalk),
		_MSG(Topen),
		_MSG(Ropen),
		_MSG(Tcreate),
		_MSG(Rcreate),
		_MSG(Tread),
		_MSG(Rread),
		_MSG(Twrite),
		_MSG(Rwrite),
		_MSG(Tclunk),
		_MSG(Rclunk),
		_MSG(Tremove),
		_MSG(Rremove),
		_MSG(Tstat),
		_MSG(Rstat),
		_MSG(Twstat),
		_MSG(Rwstat),
		_MSG(Tsession),
		_MSG(Rsession),
		_MSG(Tsread),
		_MSG(Rsread),
		_MSG(Tswrite),
		_MSG(Rswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG(Topenfd),
		_MSG(Ropenfd),
		_MSG(Tversion),
		_MSG(Rversion),
		_MSG(Tauth),
		_MSG(Rauth),
		_MSG(Tattach),
		_MSG(Rattach),
		_MSG(Rerror),
		_MSG(Tflush),
		_MSG(Rflush),
		_MSG(Twalk),
		_MSG(Rwalk),
		_MSG(Topen),
		_MSG(Ropen),
		_MSG(Tcreate),
		_MSG(Rcreate),
		_MSG(Tread),
		_MSG(Rread),
		_MSG(Twrite),
		_MSG(Rwrite),
		_MSG(Tclunk),
		_MSG(Rclunk),
		_MSG(Tremove),
		_MSG(Rremove),
		_MSG(Tstat),
		_MSG(Rstat),
		_MSG(Twstat),
		_MSG(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG(Tversion),
		_MSG(Rversion),
		_MSG(Tauth),
		_MSG(Rauth),
		_MSG(Tattach),
		_MSG(Rattach),
		_MSG(Rerror),
		_MSG(Tflush),
		_MSG(Rflush),
		_MSG(Twalk),
		_MSG(Rwalk),
		_MSG(Topen),
		_MSG(Ropen),
		_MSG(Tcreate),
		_MSG(Rcreate),
		_MSG(Tread),
		_MSG(Rread),
		_MSG(Twrite),
		_MSG(Rwrite),
		_MSG(Tclunk),
		_MSG(Rclunk),
		_MSG(Tremove),
		_MSG(Rremove),
		_MSG(Tstat),
		_MSG(Rstat),
		_MSG(Twstat),
		_MSG(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = {
		_MSG(Tversion),
		_MSG(Rversion),
		_MSG(Rerror),
	},
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

#define _MSG_RECV(typ) [LIB9P_TYP_##typ/2] = {                 \
		.validate  = validate_##typ,                   \
		.unmarshal = (_unmarshal_fn_t)unmarshal_##typ, \
	}
#define _MSG_SEND(typ) [LIB9P_TYP_##typ/2] = {             \
		.marshal   = (_marshal_fn_t)marshal_##typ, \
	}

const struct _lib9p_recv_tentry _lib9p_table_Tmsg_recv[LIB9P_VER_NUM][0x80] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Topen),
		_MSG_RECV(Tcreate),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
		_MSG_RECV(Tstat),
		_MSG_RECV(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_RECV(Tstatfs),
		_MSG_RECV(Tlopen),
		_MSG_RECV(Tlcreate),
		_MSG_RECV(Tsymlink),
		_MSG_RECV(Tmknod),
		_MSG_RECV(Trename),
		_MSG_RECV(Treadlink),
		_MSG_RECV(Tgetattr),
		_MSG_RECV(Tsetattr),
		_MSG_RECV(Txattrwalk),
		_MSG_RECV(Txattrcreate),
		_MSG_RECV(Treaddir),
		_MSG_RECV(Tfsync),
		_MSG_RECV(Tlock),
		_MSG_RECV(Tgetlock),
		_MSG_RECV(Tlink),
		_MSG_RECV(Tmkdir),
		_MSG_RECV(Trenameat),
		_MSG_RECV(Tunlinkat),
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Topen),
		_MSG_RECV(Tcreate),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
		_MSG_RECV(Tstat),
		_MSG_RECV(Twstat),
		_MSG_RECV(Tsession),
		_MSG_RECV(Tsread),
		_MSG_RECV(Tswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_RECV(Topenfd),
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Topen),
		_MSG_RECV(Tcreate),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
		_MSG_RECV(Tstat),
		_MSG_RECV(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Topen),
		_MSG_RECV(Tcreate),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
		_MSG_RECV(Tstat),
		_MSG_RECV(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = {
		_MSG_RECV(Tversion),
	},
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

const struct _lib9p_recv_tentry _lib9p_table_Rmsg_recv[LIB9P_VER_NUM][0x80] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Ropen),
		_MSG_RECV(Rcreate),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
		_MSG_RECV(Rstat),
		_MSG_RECV(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_RECV(Rlerror),
		_MSG_RECV(Rstatfs),
		_MSG_RECV(Rlopen),
		_MSG_RECV(Rlcreate),
		_MSG_RECV(Rsymlink),
		_MSG_RECV(Rmknod),
		_MSG_RECV(Rrename),
		_MSG_RECV(Rreadlink),
		_MSG_RECV(Rgetattr),
		_MSG_RECV(Rsetattr),
		_MSG_RECV(Rxattrwalk),
		_MSG_RECV(Rxattrcreate),
		_MSG_RECV(Rreaddir),
		_MSG_RECV(Rfsync),
		_MSG_RECV(Rlock),
		_MSG_RECV(Rgetlock),
		_MSG_RECV(Rlink),
		_MSG_RECV(Rmkdir),
		_MSG_RECV(Rrenameat),
		_MSG_RECV(Runlinkat),
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Ropen),
		_MSG_RECV(Rcreate),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
		_MSG_RECV(Rstat),
		_MSG_RECV(Rwstat),
		_MSG_RECV(Rsession),
		_MSG_RECV(Rsread),
		_MSG_RECV(Rswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_RECV(Ropenfd),
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Ropen),
		_MSG_RECV(Rcreate),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
		_MSG_RECV(Rstat),
		_MSG_RECV(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Ropen),
		_MSG_RECV(Rcreate),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
		_MSG_RECV(Rstat),
		_MSG_RECV(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = {
		_MSG_RECV(Rversion),
		_MSG_RECV(Rerror),
	},
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

const struct _lib9p_send_tentry _lib9p_table_Tmsg_send[LIB9P_VER_NUM][0x80] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Topen),
		_MSG_SEND(Tcreate),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
		_MSG_SEND(Tstat),
		_MSG_SEND(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_SEND(Tstatfs),
		_MSG_SEND(Tlopen),
		_MSG_SEND(Tlcreate),
		_MSG_SEND(Tsymlink),
		_MSG_SEND(Tmknod),
		_MSG_SEND(Trename),
		_MSG_SEND(Treadlink),
		_MSG_SEND(Tgetattr),
		_MSG_SEND(Tsetattr),
		_MSG_SEND(Txattrwalk),
		_MSG_SEND(Txattrcreate),
		_MSG_SEND(Treaddir),
		_MSG_SEND(Tfsync),
		_MSG_SEND(Tlock),
		_MSG_SEND(Tgetlock),
		_MSG_SEND(Tlink),
		_MSG_SEND(Tmkdir),
		_MSG_SEND(Trenameat),
		_MSG_SEND(Tunlinkat),
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Topen),
		_MSG_SEND(Tcreate),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
		_MSG_SEND(Tstat),
		_MSG_SEND(Twstat),
		_MSG_SEND(Tsession),
		_MSG_SEND(Tsread),
		_MSG_SEND(Tswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_SEND(Topenfd),
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Topen),
		_MSG_SEND(Tcreate),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
		_MSG_SEND(Tstat),
		_MSG_SEND(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Topen),
		_MSG_SEND(Tcreate),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
		_MSG_SEND(Tstat),
		_MSG_SEND(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = {
		_MSG_SEND(Tversion),
	},
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

const struct _lib9p_send_tentry _lib9p_table_Rmsg_send[LIB9P_VER_NUM][0x80] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Ropen),
		_MSG_SEND(Rcreate),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
		_MSG_SEND(Rstat),
		_MSG_SEND(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_SEND(Rlerror),
		_MSG_SEND(Rstatfs),
		_MSG_SEND(Rlopen),
		_MSG_SEND(Rlcreate),
		_MSG_SEND(Rsymlink),
		_MSG_SEND(Rmknod),
		_MSG_SEND(Rrename),
		_MSG_SEND(Rreadlink),
		_MSG_SEND(Rgetattr),
		_MSG_SEND(Rsetattr),
		_MSG_SEND(Rxattrwalk),
		_MSG_SEND(Rxattrcreate),
		_MSG_SEND(Rreaddir),
		_MSG_SEND(Rfsync),
		_MSG_SEND(Rlock),
		_MSG_SEND(Rgetlock),
		_MSG_SEND(Rlink),
		_MSG_SEND(Rmkdir),
		_MSG_SEND(Rrenameat),
		_MSG_SEND(Runlinkat),
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Ropen),
		_MSG_SEND(Rcreate),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
		_MSG_SEND(Rstat),
		_MSG_SEND(Rwstat),
		_MSG_SEND(Rsession),
		_MSG_SEND(Rsread),
		_MSG_SEND(Rswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_SEND(Ropenfd),
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Ropen),
		_MSG_SEND(Rcreate),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
		_MSG_SEND(Rstat),
		_MSG_SEND(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Ropen),
		_MSG_SEND(Rcreate),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
		_MSG_SEND(Rstat),
		_MSG_SEND(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_uninitialized
	[LIB9P_VER_uninitialized] = {
		_MSG_SEND(Rversion),
		_MSG_SEND(Rerror),
	},
#endif /* CONFIG_9P_ENABLE_uninitialized */
};

#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
LM_FLATTEN ssize_t _lib9p_stat_validate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_bytes, uint32_t *ret_net_size) {
	return validate_stat(ctx, net_size, net_bytes, ret_net_size);
}
LM_FLATTEN void _lib9p_stat_unmarshal(struct lib9p_ctx *ctx, uint8_t *net_bytes, void *out) {
	unmarshal_stat(ctx, net_bytes, out);
}
LM_FLATTEN bool _lib9p_stat_marshal(struct lib9p_ctx *ctx, struct lib9p_stat *val, struct _marshal_ret *ret) {
	return marshal_stat(ctx, val, ret);
}
#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */