/*
 * Please do not edit this file.
 * It was generated using rpcgen.
 */

#include "guestfs_protocol.h"
#include <config.h>

bool_t
xdr_guestfs_str (XDR *xdrs, guestfs_str *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, objp, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_int_bool (XDR *xdrs, guestfs_int_int_bool *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->i))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->b))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_int_bool_list (XDR *xdrs, guestfs_int_int_bool_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_int_bool_list_val, (u_int *) &objp->guestfs_int_int_bool_list_len, ~0,
		sizeof (guestfs_int_int_bool), (xdrproc_t) xdr_guestfs_int_int_bool))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_lvm_pv (XDR *xdrs, guestfs_int_lvm_pv *objp)
{
	register int32_t *buf;

	int i;
	 if (!xdr_string (xdrs, &objp->pv_name, ~0))
		 return FALSE;
	 if (!xdr_opaque (xdrs, objp->pv_uuid, 32))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->pv_fmt, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pv_size))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->dev_size))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pv_free))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pv_used))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->pv_attr, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pv_pe_count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pv_pe_alloc_count))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->pv_tags, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pe_start))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pv_mda_count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pv_mda_free))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_lvm_pv_list (XDR *xdrs, guestfs_int_lvm_pv_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_lvm_pv_list_val, (u_int *) &objp->guestfs_int_lvm_pv_list_len, ~0,
		sizeof (guestfs_int_lvm_pv), (xdrproc_t) xdr_guestfs_int_lvm_pv))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_lvm_vg (XDR *xdrs, guestfs_int_lvm_vg *objp)
{
	register int32_t *buf;

	int i;
	 if (!xdr_string (xdrs, &objp->vg_name, ~0))
		 return FALSE;
	 if (!xdr_opaque (xdrs, objp->vg_uuid, 32))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->vg_fmt, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->vg_attr, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->vg_size))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->vg_free))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->vg_sysid, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->vg_extent_size))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->vg_extent_count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->vg_free_count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->max_lv))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->max_pv))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->pv_count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->lv_count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->snap_count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->vg_seqno))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->vg_tags, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->vg_mda_count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->vg_mda_free))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_lvm_vg_list (XDR *xdrs, guestfs_int_lvm_vg_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_lvm_vg_list_val, (u_int *) &objp->guestfs_int_lvm_vg_list_len, ~0,
		sizeof (guestfs_int_lvm_vg), (xdrproc_t) xdr_guestfs_int_lvm_vg))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_lvm_lv (XDR *xdrs, guestfs_int_lvm_lv *objp)
{
	register int32_t *buf;

	int i;
	 if (!xdr_string (xdrs, &objp->lv_name, ~0))
		 return FALSE;
	 if (!xdr_opaque (xdrs, objp->lv_uuid, 32))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->lv_attr, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->lv_major))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->lv_minor))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->lv_kernel_major))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->lv_kernel_minor))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->lv_size))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->seg_count))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->origin, ~0))
		 return FALSE;
	 if (!xdr_float (xdrs, &objp->snap_percent))
		 return FALSE;
	 if (!xdr_float (xdrs, &objp->copy_percent))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->move_pv, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->lv_tags, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mirror_log, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->modules, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_lvm_lv_list (XDR *xdrs, guestfs_int_lvm_lv_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_lvm_lv_list_val, (u_int *) &objp->guestfs_int_lvm_lv_list_len, ~0,
		sizeof (guestfs_int_lvm_lv), (xdrproc_t) xdr_guestfs_int_lvm_lv))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_stat (XDR *xdrs, guestfs_int_stat *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->dev))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->ino))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->mode))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->nlink))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->uid))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->gid))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->rdev))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->blksize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->blocks))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->atime))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->mtime))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->ctime))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_stat_list (XDR *xdrs, guestfs_int_stat_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_stat_list_val, (u_int *) &objp->guestfs_int_stat_list_len, ~0,
		sizeof (guestfs_int_stat), (xdrproc_t) xdr_guestfs_int_stat))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_statns (XDR *xdrs, guestfs_int_statns *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->st_dev))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_ino))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_mode))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_nlink))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_uid))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_gid))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_rdev))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_size))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_blksize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_blocks))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_atime_sec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_atime_nsec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_mtime_sec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_mtime_nsec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_ctime_sec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_ctime_nsec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_spare1))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_spare2))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_spare3))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_spare4))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_spare5))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->st_spare6))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_statns_list (XDR *xdrs, guestfs_int_statns_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_statns_list_val, (u_int *) &objp->guestfs_int_statns_list_len, ~0,
		sizeof (guestfs_int_statns), (xdrproc_t) xdr_guestfs_int_statns))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_statvfs (XDR *xdrs, guestfs_int_statvfs *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->bsize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->frsize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->blocks))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->bfree))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->bavail))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->files))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->ffree))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->favail))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->fsid))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->flag))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->namemax))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_statvfs_list (XDR *xdrs, guestfs_int_statvfs_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_statvfs_list_val, (u_int *) &objp->guestfs_int_statvfs_list_len, ~0,
		sizeof (guestfs_int_statvfs), (xdrproc_t) xdr_guestfs_int_statvfs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_dirent (XDR *xdrs, guestfs_int_dirent *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->ino))
		 return FALSE;
	 if (!xdr_char (xdrs, &objp->ftyp))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_dirent_list (XDR *xdrs, guestfs_int_dirent_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_dirent_list_val, (u_int *) &objp->guestfs_int_dirent_list_len, ~0,
		sizeof (guestfs_int_dirent), (xdrproc_t) xdr_guestfs_int_dirent))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_version (XDR *xdrs, guestfs_int_version *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->major))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->minor))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->release))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->extra, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_version_list (XDR *xdrs, guestfs_int_version_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_version_list_val, (u_int *) &objp->guestfs_int_version_list_len, ~0,
		sizeof (guestfs_int_version), (xdrproc_t) xdr_guestfs_int_version))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_xattr (XDR *xdrs, guestfs_int_xattr *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->attrname, ~0))
		 return FALSE;
	 if (!xdr_bytes (xdrs, (char **)&objp->attrval.attrval_val, (u_int *) &objp->attrval.attrval_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_xattr_list (XDR *xdrs, guestfs_int_xattr_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_xattr_list_val, (u_int *) &objp->guestfs_int_xattr_list_len, ~0,
		sizeof (guestfs_int_xattr), (xdrproc_t) xdr_guestfs_int_xattr))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_inotify_event (XDR *xdrs, guestfs_int_inotify_event *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->in_wd))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->in_mask))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->in_cookie))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->in_name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_inotify_event_list (XDR *xdrs, guestfs_int_inotify_event_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_inotify_event_list_val, (u_int *) &objp->guestfs_int_inotify_event_list_len, ~0,
		sizeof (guestfs_int_inotify_event), (xdrproc_t) xdr_guestfs_int_inotify_event))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_partition (XDR *xdrs, guestfs_int_partition *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->part_num))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->part_start))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->part_end))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->part_size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_partition_list (XDR *xdrs, guestfs_int_partition_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_partition_list_val, (u_int *) &objp->guestfs_int_partition_list_len, ~0,
		sizeof (guestfs_int_partition), (xdrproc_t) xdr_guestfs_int_partition))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_application (XDR *xdrs, guestfs_int_application *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->app_name, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_display_name, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->app_epoch))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_version, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_release, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_install_path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_trans_path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_publisher, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_url, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_source_package, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_summary, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app_description, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_application_list (XDR *xdrs, guestfs_int_application_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_application_list_val, (u_int *) &objp->guestfs_int_application_list_len, ~0,
		sizeof (guestfs_int_application), (xdrproc_t) xdr_guestfs_int_application))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_application2 (XDR *xdrs, guestfs_int_application2 *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->app2_name, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_display_name, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->app2_epoch))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_version, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_release, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_arch, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_install_path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_trans_path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_publisher, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_url, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_source_package, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_summary, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_description, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_spare1, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_spare2, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_spare3, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->app2_spare4, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_application2_list (XDR *xdrs, guestfs_int_application2_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_application2_list_val, (u_int *) &objp->guestfs_int_application2_list_len, ~0,
		sizeof (guestfs_int_application2), (xdrproc_t) xdr_guestfs_int_application2))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_isoinfo (XDR *xdrs, guestfs_int_isoinfo *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->iso_system_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_volume_id, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_u_int (xdrs, &objp->iso_volume_space_size))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->iso_volume_set_size))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->iso_volume_sequence_number))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->iso_logical_block_size))
				 return FALSE;

		} else {
		IXDR_PUT_U_LONG(buf, objp->iso_volume_space_size);
		IXDR_PUT_U_LONG(buf, objp->iso_volume_set_size);
		IXDR_PUT_U_LONG(buf, objp->iso_volume_sequence_number);
		IXDR_PUT_U_LONG(buf, objp->iso_logical_block_size);
		}
		 if (!xdr_string (xdrs, &objp->iso_volume_set_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_publisher_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_data_preparer_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_application_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_copyright_file_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_abstract_file_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_bibliographic_file_id, ~0))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->iso_volume_creation_t))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->iso_volume_modification_t))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->iso_volume_expiration_t))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->iso_volume_effective_t))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->iso_system_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_volume_id, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_u_int (xdrs, &objp->iso_volume_space_size))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->iso_volume_set_size))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->iso_volume_sequence_number))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->iso_logical_block_size))
				 return FALSE;

		} else {
		objp->iso_volume_space_size = IXDR_GET_U_LONG(buf);
		objp->iso_volume_set_size = IXDR_GET_U_LONG(buf);
		objp->iso_volume_sequence_number = IXDR_GET_U_LONG(buf);
		objp->iso_logical_block_size = IXDR_GET_U_LONG(buf);
		}
		 if (!xdr_string (xdrs, &objp->iso_volume_set_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_publisher_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_data_preparer_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_application_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_copyright_file_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_abstract_file_id, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->iso_bibliographic_file_id, ~0))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->iso_volume_creation_t))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->iso_volume_modification_t))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->iso_volume_expiration_t))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->iso_volume_effective_t))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->iso_system_id, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->iso_volume_id, ~0))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->iso_volume_space_size))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->iso_volume_set_size))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->iso_volume_sequence_number))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->iso_logical_block_size))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->iso_volume_set_id, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->iso_publisher_id, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->iso_data_preparer_id, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->iso_application_id, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->iso_copyright_file_id, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->iso_abstract_file_id, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->iso_bibliographic_file_id, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->iso_volume_creation_t))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->iso_volume_modification_t))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->iso_volume_expiration_t))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->iso_volume_effective_t))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_isoinfo_list (XDR *xdrs, guestfs_int_isoinfo_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_isoinfo_list_val, (u_int *) &objp->guestfs_int_isoinfo_list_len, ~0,
		sizeof (guestfs_int_isoinfo), (xdrproc_t) xdr_guestfs_int_isoinfo))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_mdstat (XDR *xdrs, guestfs_int_mdstat *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mdstat_device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mdstat_index))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mdstat_flags, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_mdstat_list (XDR *xdrs, guestfs_int_mdstat_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_mdstat_list_val, (u_int *) &objp->guestfs_int_mdstat_list_len, ~0,
		sizeof (guestfs_int_mdstat), (xdrproc_t) xdr_guestfs_int_mdstat))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_btrfssubvolume (XDR *xdrs, guestfs_int_btrfssubvolume *objp)
{
	register int32_t *buf;

	 if (!xdr_uint64_t (xdrs, &objp->btrfssubvolume_id))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfssubvolume_top_level_id))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->btrfssubvolume_path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_btrfssubvolume_list (XDR *xdrs, guestfs_int_btrfssubvolume_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_btrfssubvolume_list_val, (u_int *) &objp->guestfs_int_btrfssubvolume_list_len, ~0,
		sizeof (guestfs_int_btrfssubvolume), (xdrproc_t) xdr_guestfs_int_btrfssubvolume))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_btrfsqgroup (XDR *xdrs, guestfs_int_btrfsqgroup *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->btrfsqgroup_id, ~0))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsqgroup_rfer))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsqgroup_excl))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_btrfsqgroup_list (XDR *xdrs, guestfs_int_btrfsqgroup_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_btrfsqgroup_list_val, (u_int *) &objp->guestfs_int_btrfsqgroup_list_len, ~0,
		sizeof (guestfs_int_btrfsqgroup), (xdrproc_t) xdr_guestfs_int_btrfsqgroup))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_btrfsbalance (XDR *xdrs, guestfs_int_btrfsbalance *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->btrfsbalance_status, ~0))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsbalance_total))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsbalance_balanced))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsbalance_considered))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsbalance_left))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_btrfsbalance_list (XDR *xdrs, guestfs_int_btrfsbalance_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_btrfsbalance_list_val, (u_int *) &objp->guestfs_int_btrfsbalance_list_len, ~0,
		sizeof (guestfs_int_btrfsbalance), (xdrproc_t) xdr_guestfs_int_btrfsbalance))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_btrfsscrub (XDR *xdrs, guestfs_int_btrfsscrub *objp)
{
	register int32_t *buf;

	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_data_extents_scrubbed))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_tree_extents_scrubbed))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_data_bytes_scrubbed))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_tree_bytes_scrubbed))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_read_errors))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_csum_errors))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_verify_errors))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_no_csum))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_csum_discards))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_super_errors))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_malloc_errors))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_uncorrectable_errors))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_unverified_errors))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_corrected_errors))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->btrfsscrub_last_physical))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_btrfsscrub_list (XDR *xdrs, guestfs_int_btrfsscrub_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_btrfsscrub_list_val, (u_int *) &objp->guestfs_int_btrfsscrub_list_len, ~0,
		sizeof (guestfs_int_btrfsscrub), (xdrproc_t) xdr_guestfs_int_btrfsscrub))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_xfsinfo (XDR *xdrs, guestfs_int_xfsinfo *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->xfs_mntpoint, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_u_int (xdrs, &objp->xfs_inodesize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_agcount))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_agsize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_sectsize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_attr))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_blocksize))
				 return FALSE;

		} else {
		IXDR_PUT_U_LONG(buf, objp->xfs_inodesize);
		IXDR_PUT_U_LONG(buf, objp->xfs_agcount);
		IXDR_PUT_U_LONG(buf, objp->xfs_agsize);
		IXDR_PUT_U_LONG(buf, objp->xfs_sectsize);
		IXDR_PUT_U_LONG(buf, objp->xfs_attr);
		IXDR_PUT_U_LONG(buf, objp->xfs_blocksize);
		}
		 if (!xdr_uint64_t (xdrs, &objp->xfs_datablocks))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_u_int (xdrs, &objp->xfs_imaxpct))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_sunit))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_swidth))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_dirversion))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_dirblocksize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_cimode))
				 return FALSE;

		} else {
		IXDR_PUT_U_LONG(buf, objp->xfs_imaxpct);
		IXDR_PUT_U_LONG(buf, objp->xfs_sunit);
		IXDR_PUT_U_LONG(buf, objp->xfs_swidth);
		IXDR_PUT_U_LONG(buf, objp->xfs_dirversion);
		IXDR_PUT_U_LONG(buf, objp->xfs_dirblocksize);
		IXDR_PUT_U_LONG(buf, objp->xfs_cimode);
		}
		 if (!xdr_string (xdrs, &objp->xfs_logname, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_u_int (xdrs, &objp->xfs_logblocksize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_logblocks))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_logversion))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_logsectsize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_logsunit))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_lazycount))
				 return FALSE;

		} else {
		IXDR_PUT_U_LONG(buf, objp->xfs_logblocksize);
		IXDR_PUT_U_LONG(buf, objp->xfs_logblocks);
		IXDR_PUT_U_LONG(buf, objp->xfs_logversion);
		IXDR_PUT_U_LONG(buf, objp->xfs_logsectsize);
		IXDR_PUT_U_LONG(buf, objp->xfs_logsunit);
		IXDR_PUT_U_LONG(buf, objp->xfs_lazycount);
		}
		 if (!xdr_string (xdrs, &objp->xfs_rtname, ~0))
			 return FALSE;
		 if (!xdr_u_int (xdrs, &objp->xfs_rtextsize))
			 return FALSE;
		 if (!xdr_uint64_t (xdrs, &objp->xfs_rtblocks))
			 return FALSE;
		 if (!xdr_uint64_t (xdrs, &objp->xfs_rtextents))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->xfs_mntpoint, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_u_int (xdrs, &objp->xfs_inodesize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_agcount))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_agsize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_sectsize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_attr))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_blocksize))
				 return FALSE;

		} else {
		objp->xfs_inodesize = IXDR_GET_U_LONG(buf);
		objp->xfs_agcount = IXDR_GET_U_LONG(buf);
		objp->xfs_agsize = IXDR_GET_U_LONG(buf);
		objp->xfs_sectsize = IXDR_GET_U_LONG(buf);
		objp->xfs_attr = IXDR_GET_U_LONG(buf);
		objp->xfs_blocksize = IXDR_GET_U_LONG(buf);
		}
		 if (!xdr_uint64_t (xdrs, &objp->xfs_datablocks))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_u_int (xdrs, &objp->xfs_imaxpct))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_sunit))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_swidth))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_dirversion))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_dirblocksize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_cimode))
				 return FALSE;

		} else {
		objp->xfs_imaxpct = IXDR_GET_U_LONG(buf);
		objp->xfs_sunit = IXDR_GET_U_LONG(buf);
		objp->xfs_swidth = IXDR_GET_U_LONG(buf);
		objp->xfs_dirversion = IXDR_GET_U_LONG(buf);
		objp->xfs_dirblocksize = IXDR_GET_U_LONG(buf);
		objp->xfs_cimode = IXDR_GET_U_LONG(buf);
		}
		 if (!xdr_string (xdrs, &objp->xfs_logname, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_u_int (xdrs, &objp->xfs_logblocksize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_logblocks))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_logversion))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_logsectsize))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_logsunit))
				 return FALSE;
			 if (!xdr_u_int (xdrs, &objp->xfs_lazycount))
				 return FALSE;

		} else {
		objp->xfs_logblocksize = IXDR_GET_U_LONG(buf);
		objp->xfs_logblocks = IXDR_GET_U_LONG(buf);
		objp->xfs_logversion = IXDR_GET_U_LONG(buf);
		objp->xfs_logsectsize = IXDR_GET_U_LONG(buf);
		objp->xfs_logsunit = IXDR_GET_U_LONG(buf);
		objp->xfs_lazycount = IXDR_GET_U_LONG(buf);
		}
		 if (!xdr_string (xdrs, &objp->xfs_rtname, ~0))
			 return FALSE;
		 if (!xdr_u_int (xdrs, &objp->xfs_rtextsize))
			 return FALSE;
		 if (!xdr_uint64_t (xdrs, &objp->xfs_rtblocks))
			 return FALSE;
		 if (!xdr_uint64_t (xdrs, &objp->xfs_rtextents))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->xfs_mntpoint, ~0))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_inodesize))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_agcount))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_agsize))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_sectsize))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_attr))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_blocksize))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->xfs_datablocks))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_imaxpct))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_sunit))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_swidth))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_dirversion))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_dirblocksize))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_cimode))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->xfs_logname, ~0))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_logblocksize))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_logblocks))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_logversion))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_logsectsize))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_logsunit))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_lazycount))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->xfs_rtname, ~0))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->xfs_rtextsize))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->xfs_rtblocks))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->xfs_rtextents))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_xfsinfo_list (XDR *xdrs, guestfs_int_xfsinfo_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_xfsinfo_list_val, (u_int *) &objp->guestfs_int_xfsinfo_list_len, ~0,
		sizeof (guestfs_int_xfsinfo), (xdrproc_t) xdr_guestfs_int_xfsinfo))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_utsname (XDR *xdrs, guestfs_int_utsname *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uts_sysname, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uts_release, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uts_version, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uts_machine, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_utsname_list (XDR *xdrs, guestfs_int_utsname_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_utsname_list_val, (u_int *) &objp->guestfs_int_utsname_list_len, ~0,
		sizeof (guestfs_int_utsname), (xdrproc_t) xdr_guestfs_int_utsname))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_hivex_node (XDR *xdrs, guestfs_int_hivex_node *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->hivex_node_h))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_hivex_node_list (XDR *xdrs, guestfs_int_hivex_node_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_hivex_node_list_val, (u_int *) &objp->guestfs_int_hivex_node_list_len, ~0,
		sizeof (guestfs_int_hivex_node), (xdrproc_t) xdr_guestfs_int_hivex_node))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_hivex_value (XDR *xdrs, guestfs_int_hivex_value *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->hivex_value_h))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_hivex_value_list (XDR *xdrs, guestfs_int_hivex_value_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_hivex_value_list_val, (u_int *) &objp->guestfs_int_hivex_value_list_len, ~0,
		sizeof (guestfs_int_hivex_value), (xdrproc_t) xdr_guestfs_int_hivex_value))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_internal_mountable (XDR *xdrs, guestfs_int_internal_mountable *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->im_type))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->im_device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->im_volume, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_internal_mountable_list (XDR *xdrs, guestfs_int_internal_mountable_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_internal_mountable_list_val, (u_int *) &objp->guestfs_int_internal_mountable_list_len, ~0,
		sizeof (guestfs_int_internal_mountable), (xdrproc_t) xdr_guestfs_int_internal_mountable))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_tsk_dirent (XDR *xdrs, guestfs_int_tsk_dirent *objp)
{
	register int32_t *buf;

	 if (!xdr_uint64_t (xdrs, &objp->tsk_inode))
		 return FALSE;
	 if (!xdr_char (xdrs, &objp->tsk_type))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_size))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->tsk_name, ~0))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->tsk_flags))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_atime_sec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_atime_nsec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_mtime_sec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_mtime_nsec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_ctime_sec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_ctime_nsec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_crtime_sec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_crtime_nsec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_nlink))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->tsk_link, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->tsk_spare1))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_tsk_dirent_list (XDR *xdrs, guestfs_int_tsk_dirent_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_tsk_dirent_list_val, (u_int *) &objp->guestfs_int_tsk_dirent_list_len, ~0,
		sizeof (guestfs_int_tsk_dirent), (xdrproc_t) xdr_guestfs_int_tsk_dirent))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_yara_detection (XDR *xdrs, guestfs_int_yara_detection *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->yara_name, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->yara_rule, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_int_yara_detection_list (XDR *xdrs, guestfs_int_yara_detection_list *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guestfs_int_yara_detection_list_val, (u_int *) &objp->guestfs_int_yara_detection_list_len, ~0,
		sizeof (guestfs_int_yara_detection), (xdrproc_t) xdr_guestfs_int_yara_detection))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_acl_delete_def_file_args (XDR *xdrs, guestfs_acl_delete_def_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->dir, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_acl_get_file_args (XDR *xdrs, guestfs_acl_get_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->acltype, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_acl_get_file_ret (XDR *xdrs, guestfs_acl_get_file_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->acl, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_acl_set_file_args (XDR *xdrs, guestfs_acl_set_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->acltype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->acl, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_clear_args (XDR *xdrs, guestfs_aug_clear_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->augpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_defnode_args (XDR *xdrs, guestfs_aug_defnode_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->expr, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->val, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_defnode_ret (XDR *xdrs, guestfs_aug_defnode_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_int_bool (xdrs, &objp->nrnodescreated))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_defvar_args (XDR *xdrs, guestfs_aug_defvar_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	 if (!xdr_pointer (xdrs, (char **)&objp->expr, sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_defvar_ret (XDR *xdrs, guestfs_aug_defvar_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->nrnodes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_get_args (XDR *xdrs, guestfs_aug_get_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->augpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_get_ret (XDR *xdrs, guestfs_aug_get_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->val, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_init_args (XDR *xdrs, guestfs_aug_init_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->flags))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_insert_args (XDR *xdrs, guestfs_aug_insert_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->augpath, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->before))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_label_args (XDR *xdrs, guestfs_aug_label_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->augpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_label_ret (XDR *xdrs, guestfs_aug_label_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_ls_args (XDR *xdrs, guestfs_aug_ls_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->augpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_ls_ret (XDR *xdrs, guestfs_aug_ls_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->matches.matches_val, (u_int *) &objp->matches.matches_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_match_args (XDR *xdrs, guestfs_aug_match_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->augpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_match_ret (XDR *xdrs, guestfs_aug_match_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->matches.matches_val, (u_int *) &objp->matches.matches_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_mv_args (XDR *xdrs, guestfs_aug_mv_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_rm_args (XDR *xdrs, guestfs_aug_rm_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->augpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_rm_ret (XDR *xdrs, guestfs_aug_rm_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->nrnodes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_set_args (XDR *xdrs, guestfs_aug_set_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->augpath, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->val, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_setm_args (XDR *xdrs, guestfs_aug_setm_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->base, ~0))
		 return FALSE;
	 if (!xdr_pointer (xdrs, (char **)&objp->sub, sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->val, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_setm_ret (XDR *xdrs, guestfs_aug_setm_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->nodes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_aug_transform_args (XDR *xdrs, guestfs_aug_transform_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->lens, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->remove))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_available_all_groups_ret (XDR *xdrs, guestfs_available_all_groups_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_base64_in_args (XDR *xdrs, guestfs_base64_in_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->filename, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_base64_out_args (XDR *xdrs, guestfs_base64_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->filename, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blkdiscard_args (XDR *xdrs, guestfs_blkdiscard_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blkdiscardzeroes_args (XDR *xdrs, guestfs_blkdiscardzeroes_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blkdiscardzeroes_ret (XDR *xdrs, guestfs_blkdiscardzeroes_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->zeroes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blkid_args (XDR *xdrs, guestfs_blkid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blkid_ret (XDR *xdrs, guestfs_blkid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->info.info_val, (u_int *) &objp->info.info_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_flushbufs_args (XDR *xdrs, guestfs_blockdev_flushbufs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getbsz_args (XDR *xdrs, guestfs_blockdev_getbsz_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getbsz_ret (XDR *xdrs, guestfs_blockdev_getbsz_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getro_args (XDR *xdrs, guestfs_blockdev_getro_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getro_ret (XDR *xdrs, guestfs_blockdev_getro_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->ro))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getsize64_args (XDR *xdrs, guestfs_blockdev_getsize64_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getsize64_ret (XDR *xdrs, guestfs_blockdev_getsize64_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->sizeinbytes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getss_args (XDR *xdrs, guestfs_blockdev_getss_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getss_ret (XDR *xdrs, guestfs_blockdev_getss_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->sectorsize))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getsz_args (XDR *xdrs, guestfs_blockdev_getsz_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_getsz_ret (XDR *xdrs, guestfs_blockdev_getsz_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->sizeinsectors))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_rereadpt_args (XDR *xdrs, guestfs_blockdev_rereadpt_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_setbsz_args (XDR *xdrs, guestfs_blockdev_setbsz_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_setra_args (XDR *xdrs, guestfs_blockdev_setra_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->sectors))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_setro_args (XDR *xdrs, guestfs_blockdev_setro_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_blockdev_setrw_args (XDR *xdrs, guestfs_blockdev_setrw_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_balance_cancel_args (XDR *xdrs, guestfs_btrfs_balance_cancel_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_balance_pause_args (XDR *xdrs, guestfs_btrfs_balance_pause_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_balance_resume_args (XDR *xdrs, guestfs_btrfs_balance_resume_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_balance_status_args (XDR *xdrs, guestfs_btrfs_balance_status_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_balance_status_ret (XDR *xdrs, guestfs_btrfs_balance_status_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_btrfsbalance (xdrs, &objp->status))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_device_add_args (XDR *xdrs, guestfs_btrfs_device_add_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_device_delete_args (XDR *xdrs, guestfs_btrfs_device_delete_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_filesystem_balance_args (XDR *xdrs, guestfs_btrfs_filesystem_balance_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_filesystem_defragment_args (XDR *xdrs, guestfs_btrfs_filesystem_defragment_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->flush))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->compress, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_filesystem_resize_args (XDR *xdrs, guestfs_btrfs_filesystem_resize_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_filesystem_show_args (XDR *xdrs, guestfs_btrfs_filesystem_show_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_filesystem_show_ret (XDR *xdrs, guestfs_btrfs_filesystem_show_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_filesystem_sync_args (XDR *xdrs, guestfs_btrfs_filesystem_sync_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_fsck_args (XDR *xdrs, guestfs_btrfs_fsck_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->superblock))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->repair))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_image_args (XDR *xdrs, guestfs_btrfs_image_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->source.source_val, (u_int *) &objp->source.source_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->image, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->compresslevel))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_qgroup_assign_args (XDR *xdrs, guestfs_btrfs_qgroup_assign_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dst, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_qgroup_create_args (XDR *xdrs, guestfs_btrfs_qgroup_create_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->qgroupid, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->subvolume, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_qgroup_destroy_args (XDR *xdrs, guestfs_btrfs_qgroup_destroy_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->qgroupid, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->subvolume, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_qgroup_limit_args (XDR *xdrs, guestfs_btrfs_qgroup_limit_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->subvolume, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_qgroup_remove_args (XDR *xdrs, guestfs_btrfs_qgroup_remove_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dst, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_qgroup_show_args (XDR *xdrs, guestfs_btrfs_qgroup_show_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_qgroup_show_ret (XDR *xdrs, guestfs_btrfs_qgroup_show_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_btrfsqgroup_list (xdrs, &objp->qgroups))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_quota_enable_args (XDR *xdrs, guestfs_btrfs_quota_enable_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->enable))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_quota_rescan_args (XDR *xdrs, guestfs_btrfs_quota_rescan_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_replace_args (XDR *xdrs, guestfs_btrfs_replace_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->srcdev, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->targetdev, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mntpoint, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_rescue_chunk_recover_args (XDR *xdrs, guestfs_btrfs_rescue_chunk_recover_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_rescue_super_recover_args (XDR *xdrs, guestfs_btrfs_rescue_super_recover_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_scrub_cancel_args (XDR *xdrs, guestfs_btrfs_scrub_cancel_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_scrub_resume_args (XDR *xdrs, guestfs_btrfs_scrub_resume_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_scrub_start_args (XDR *xdrs, guestfs_btrfs_scrub_start_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_scrub_status_args (XDR *xdrs, guestfs_btrfs_scrub_status_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_scrub_status_ret (XDR *xdrs, guestfs_btrfs_scrub_status_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_btrfsscrub (xdrs, &objp->status))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_set_seeding_args (XDR *xdrs, guestfs_btrfs_set_seeding_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->seeding))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_create_args (XDR *xdrs, guestfs_btrfs_subvolume_create_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->qgroupid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_delete_args (XDR *xdrs, guestfs_btrfs_subvolume_delete_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->subvolume, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_get_default_args (XDR *xdrs, guestfs_btrfs_subvolume_get_default_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_get_default_ret (XDR *xdrs, guestfs_btrfs_subvolume_get_default_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->id))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_list_args (XDR *xdrs, guestfs_btrfs_subvolume_list_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_list_ret (XDR *xdrs, guestfs_btrfs_subvolume_list_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_btrfssubvolume_list (xdrs, &objp->subvolumes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_set_default_args (XDR *xdrs, guestfs_btrfs_subvolume_set_default_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->id))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->fs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_show_args (XDR *xdrs, guestfs_btrfs_subvolume_show_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->subvolume, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_show_ret (XDR *xdrs, guestfs_btrfs_subvolume_show_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->btrfssubvolumeinfo.btrfssubvolumeinfo_val, (u_int *) &objp->btrfssubvolumeinfo.btrfssubvolumeinfo_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfs_subvolume_snapshot_args (XDR *xdrs, guestfs_btrfs_subvolume_snapshot_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->source, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->ro))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->qgroupid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfstune_enable_extended_inode_refs_args (XDR *xdrs, guestfs_btrfstune_enable_extended_inode_refs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfstune_enable_skinny_metadata_extent_refs_args (XDR *xdrs, guestfs_btrfstune_enable_skinny_metadata_extent_refs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_btrfstune_seeding_args (XDR *xdrs, guestfs_btrfstune_seeding_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->seeding))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cap_get_file_args (XDR *xdrs, guestfs_cap_get_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cap_get_file_ret (XDR *xdrs, guestfs_cap_get_file_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->cap, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cap_set_file_args (XDR *xdrs, guestfs_cap_set_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->cap, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_case_sensitive_path_args (XDR *xdrs, guestfs_case_sensitive_path_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_case_sensitive_path_ret (XDR *xdrs, guestfs_case_sensitive_path_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->rpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_checksum_args (XDR *xdrs, guestfs_checksum_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->csumtype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_checksum_ret (XDR *xdrs, guestfs_checksum_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->checksum, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_checksum_device_args (XDR *xdrs, guestfs_checksum_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->csumtype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_checksum_device_ret (XDR *xdrs, guestfs_checksum_device_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->checksum, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_checksums_out_args (XDR *xdrs, guestfs_checksums_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->csumtype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_chmod_args (XDR *xdrs, guestfs_chmod_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->mode))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_chown_args (XDR *xdrs, guestfs_chown_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->owner))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->group))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_command_args (XDR *xdrs, guestfs_command_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->arguments.arguments_val, (u_int *) &objp->arguments.arguments_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_command_ret (XDR *xdrs, guestfs_command_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->output, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_command_lines_args (XDR *xdrs, guestfs_command_lines_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->arguments.arguments_val, (u_int *) &objp->arguments.arguments_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_command_lines_ret (XDR *xdrs, guestfs_command_lines_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_compress_device_out_args (XDR *xdrs, guestfs_compress_device_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->ctype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->level))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_compress_out_args (XDR *xdrs, guestfs_compress_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->ctype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->level))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_copy_attributes_args (XDR *xdrs, guestfs_copy_attributes_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->src, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->dest, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->all))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->mode))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->xattributes))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->ownership))
				 return FALSE;
		} else {
			IXDR_PUT_BOOL(buf, objp->all);
			IXDR_PUT_BOOL(buf, objp->mode);
			IXDR_PUT_BOOL(buf, objp->xattributes);
			IXDR_PUT_BOOL(buf, objp->ownership);
		}
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->src, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->dest, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->all))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->mode))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->xattributes))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->ownership))
				 return FALSE;
		} else {
			objp->all = IXDR_GET_BOOL(buf);
			objp->mode = IXDR_GET_BOOL(buf);
			objp->xattributes = IXDR_GET_BOOL(buf);
			objp->ownership = IXDR_GET_BOOL(buf);
		}
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->all))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->mode))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->xattributes))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->ownership))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_copy_device_to_device_args (XDR *xdrs, guestfs_copy_device_to_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->srcoffset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->destoffset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->sparse))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->append))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_copy_device_to_file_args (XDR *xdrs, guestfs_copy_device_to_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->srcoffset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->destoffset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->sparse))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->append))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_copy_file_to_device_args (XDR *xdrs, guestfs_copy_file_to_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->srcoffset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->destoffset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->sparse))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->append))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_copy_file_to_file_args (XDR *xdrs, guestfs_copy_file_to_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->srcoffset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->destoffset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->sparse))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->append))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_copy_size_args (XDR *xdrs, guestfs_copy_size_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cp_args (XDR *xdrs, guestfs_cp_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cp_a_args (XDR *xdrs, guestfs_cp_a_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cp_r_args (XDR *xdrs, guestfs_cp_r_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cpio_out_args (XDR *xdrs, guestfs_cpio_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->format, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cryptsetup_close_args (XDR *xdrs, guestfs_cryptsetup_close_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_cryptsetup_open_args (XDR *xdrs, guestfs_cryptsetup_open_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mapname, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->readonly))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->crypttype, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_dd_args (XDR *xdrs, guestfs_dd_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_debug_args (XDR *xdrs, guestfs_debug_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->subcmd, ~0))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->extraargs.extraargs_val, (u_int *) &objp->extraargs.extraargs_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_debug_ret (XDR *xdrs, guestfs_debug_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->result, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_debug_upload_args (XDR *xdrs, guestfs_debug_upload_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->tmpname, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mode))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_df_ret (XDR *xdrs, guestfs_df_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->output, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_df_h_ret (XDR *xdrs, guestfs_df_h_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->output, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_dmesg_ret (XDR *xdrs, guestfs_dmesg_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->kmsgs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_download_args (XDR *xdrs, guestfs_download_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->remotefilename, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_download_blocks_args (XDR *xdrs, guestfs_download_blocks_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->start))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->stop))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->unallocated))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_download_inode_args (XDR *xdrs, guestfs_download_inode_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->inode))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_download_offset_args (XDR *xdrs, guestfs_download_offset_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->remotefilename, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->offset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_drop_caches_args (XDR *xdrs, guestfs_drop_caches_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->whattodrop))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_du_args (XDR *xdrs, guestfs_du_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_du_ret (XDR *xdrs, guestfs_du_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->sizekb))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_e2fsck_args (XDR *xdrs, guestfs_e2fsck_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->correct))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->forceall))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_e2fsck_f_args (XDR *xdrs, guestfs_e2fsck_f_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_echo_daemon_args (XDR *xdrs, guestfs_echo_daemon_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->words.words_val, (u_int *) &objp->words.words_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_echo_daemon_ret (XDR *xdrs, guestfs_echo_daemon_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->output, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_egrep_args (XDR *xdrs, guestfs_egrep_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->regex, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_egrep_ret (XDR *xdrs, guestfs_egrep_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_egrepi_args (XDR *xdrs, guestfs_egrepi_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->regex, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_egrepi_ret (XDR *xdrs, guestfs_egrepi_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_equal_args (XDR *xdrs, guestfs_equal_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file1, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->file2, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_equal_ret (XDR *xdrs, guestfs_equal_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->equality))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_exists_args (XDR *xdrs, guestfs_exists_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_exists_ret (XDR *xdrs, guestfs_exists_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->existsflag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_extlinux_args (XDR *xdrs, guestfs_extlinux_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_f2fs_expand_args (XDR *xdrs, guestfs_f2fs_expand_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fallocate_args (XDR *xdrs, guestfs_fallocate_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->len))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fallocate64_args (XDR *xdrs, guestfs_fallocate64_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->len))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fgrep_args (XDR *xdrs, guestfs_fgrep_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->pattern, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fgrep_ret (XDR *xdrs, guestfs_fgrep_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fgrepi_args (XDR *xdrs, guestfs_fgrepi_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->pattern, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fgrepi_ret (XDR *xdrs, guestfs_fgrepi_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_file_args (XDR *xdrs, guestfs_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_file_ret (XDR *xdrs, guestfs_file_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->description, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_file_architecture_args (XDR *xdrs, guestfs_file_architecture_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->filename, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_file_architecture_ret (XDR *xdrs, guestfs_file_architecture_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->arch, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_filesize_args (XDR *xdrs, guestfs_filesize_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_filesize_ret (XDR *xdrs, guestfs_filesize_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_filesystem_available_args (XDR *xdrs, guestfs_filesystem_available_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->filesystem, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_filesystem_available_ret (XDR *xdrs, guestfs_filesystem_available_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->fsavail))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fill_args (XDR *xdrs, guestfs_fill_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->c))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->len))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fill_dir_args (XDR *xdrs, guestfs_fill_dir_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->dir, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->nr))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fill_pattern_args (XDR *xdrs, guestfs_fill_pattern_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->pattern, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->len))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_find0_args (XDR *xdrs, guestfs_find0_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_findfs_label_args (XDR *xdrs, guestfs_findfs_label_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_findfs_label_ret (XDR *xdrs, guestfs_findfs_label_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_findfs_uuid_args (XDR *xdrs, guestfs_findfs_uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_findfs_uuid_ret (XDR *xdrs, guestfs_findfs_uuid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fsck_args (XDR *xdrs, guestfs_fsck_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fstype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fsck_ret (XDR *xdrs, guestfs_fsck_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->status))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_fstrim_args (XDR *xdrs, guestfs_fstrim_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->offset))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->length))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->minimumfreeextent))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_e2attrs_args (XDR *xdrs, guestfs_get_e2attrs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_e2attrs_ret (XDR *xdrs, guestfs_get_e2attrs_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->attrs, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_e2generation_args (XDR *xdrs, guestfs_get_e2generation_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_e2generation_ret (XDR *xdrs, guestfs_get_e2generation_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->generation))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_e2label_args (XDR *xdrs, guestfs_get_e2label_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_e2label_ret (XDR *xdrs, guestfs_get_e2label_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_e2uuid_args (XDR *xdrs, guestfs_get_e2uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_e2uuid_ret (XDR *xdrs, guestfs_get_e2uuid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_get_umask_ret (XDR *xdrs, guestfs_get_umask_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->mask))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_getcon_ret (XDR *xdrs, guestfs_getcon_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->context, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_getxattr_args (XDR *xdrs, guestfs_getxattr_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_getxattr_ret (XDR *xdrs, guestfs_getxattr_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bytes (xdrs, (char **)&objp->xattr.xattr_val, (u_int *) &objp->xattr.xattr_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_getxattrs_args (XDR *xdrs, guestfs_getxattrs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_getxattrs_ret (XDR *xdrs, guestfs_getxattrs_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_xattr_list (xdrs, &objp->xattrs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_glob_expand_args (XDR *xdrs, guestfs_glob_expand_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->pattern, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->directoryslash))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_glob_expand_ret (XDR *xdrs, guestfs_glob_expand_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->paths.paths_val, (u_int *) &objp->paths.paths_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_grep_args (XDR *xdrs, guestfs_grep_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->regex, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->extended))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->fixed))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->insensitive))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->compressed))
				 return FALSE;
		} else {
			IXDR_PUT_BOOL(buf, objp->extended);
			IXDR_PUT_BOOL(buf, objp->fixed);
			IXDR_PUT_BOOL(buf, objp->insensitive);
			IXDR_PUT_BOOL(buf, objp->compressed);
		}
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->regex, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->extended))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->fixed))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->insensitive))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->compressed))
				 return FALSE;
		} else {
			objp->extended = IXDR_GET_BOOL(buf);
			objp->fixed = IXDR_GET_BOOL(buf);
			objp->insensitive = IXDR_GET_BOOL(buf);
			objp->compressed = IXDR_GET_BOOL(buf);
		}
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->regex, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->extended))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->fixed))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->insensitive))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->compressed))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_grep_ret (XDR *xdrs, guestfs_grep_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_grepi_args (XDR *xdrs, guestfs_grepi_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->regex, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_grepi_ret (XDR *xdrs, guestfs_grepi_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_grub_install_args (XDR *xdrs, guestfs_grub_install_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_head_args (XDR *xdrs, guestfs_head_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_head_ret (XDR *xdrs, guestfs_head_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_head_n_args (XDR *xdrs, guestfs_head_n_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->nrlines))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_head_n_ret (XDR *xdrs, guestfs_head_n_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hexdump_args (XDR *xdrs, guestfs_hexdump_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hexdump_ret (XDR *xdrs, guestfs_hexdump_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->dump, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_commit_args (XDR *xdrs, guestfs_hivex_commit_args *objp)
{
	register int32_t *buf;

	 if (!xdr_pointer (xdrs, (char **)&objp->filename, sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_add_child_args (XDR *xdrs, guestfs_hivex_node_add_child_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->parent))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_add_child_ret (XDR *xdrs, guestfs_hivex_node_add_child_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_children_args (XDR *xdrs, guestfs_hivex_node_children_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_children_ret (XDR *xdrs, guestfs_hivex_node_children_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_hivex_node_list (xdrs, &objp->nodehs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_delete_child_args (XDR *xdrs, guestfs_hivex_node_delete_child_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_get_child_args (XDR *xdrs, guestfs_hivex_node_get_child_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_get_child_ret (XDR *xdrs, guestfs_hivex_node_get_child_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->child))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_get_value_args (XDR *xdrs, guestfs_hivex_node_get_value_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_get_value_ret (XDR *xdrs, guestfs_hivex_node_get_value_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->valueh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_name_args (XDR *xdrs, guestfs_hivex_node_name_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_name_ret (XDR *xdrs, guestfs_hivex_node_name_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_parent_args (XDR *xdrs, guestfs_hivex_node_parent_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_parent_ret (XDR *xdrs, guestfs_hivex_node_parent_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->parent))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_set_value_args (XDR *xdrs, guestfs_hivex_node_set_value_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->t))
		 return FALSE;
	 if (!xdr_bytes (xdrs, (char **)&objp->val.val_val, (u_int *) &objp->val.val_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_values_args (XDR *xdrs, guestfs_hivex_node_values_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_node_values_ret (XDR *xdrs, guestfs_hivex_node_values_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_hivex_value_list (xdrs, &objp->valuehs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_open_args (XDR *xdrs, guestfs_hivex_open_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->filename, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->verbose))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->debug))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->write))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->unsafe))
				 return FALSE;
		} else {
			IXDR_PUT_BOOL(buf, objp->verbose);
			IXDR_PUT_BOOL(buf, objp->debug);
			IXDR_PUT_BOOL(buf, objp->write);
			IXDR_PUT_BOOL(buf, objp->unsafe);
		}
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->filename, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->verbose))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->debug))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->write))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->unsafe))
				 return FALSE;
		} else {
			objp->verbose = IXDR_GET_BOOL(buf);
			objp->debug = IXDR_GET_BOOL(buf);
			objp->write = IXDR_GET_BOOL(buf);
			objp->unsafe = IXDR_GET_BOOL(buf);
		}
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->filename, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->verbose))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->debug))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->write))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->unsafe))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_root_ret (XDR *xdrs, guestfs_hivex_root_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->nodeh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_key_args (XDR *xdrs, guestfs_hivex_value_key_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->valueh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_key_ret (XDR *xdrs, guestfs_hivex_value_key_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_string_args (XDR *xdrs, guestfs_hivex_value_string_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->valueh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_string_ret (XDR *xdrs, guestfs_hivex_value_string_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->databuf, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_type_args (XDR *xdrs, guestfs_hivex_value_type_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->valueh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_type_ret (XDR *xdrs, guestfs_hivex_value_type_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->datatype))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_utf8_args (XDR *xdrs, guestfs_hivex_value_utf8_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->valueh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_utf8_ret (XDR *xdrs, guestfs_hivex_value_utf8_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->databuf, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_value_args (XDR *xdrs, guestfs_hivex_value_value_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->valueh))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_hivex_value_value_ret (XDR *xdrs, guestfs_hivex_value_value_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bytes (xdrs, (char **)&objp->databuf.databuf_val, (u_int *) &objp->databuf.databuf_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_initrd_cat_args (XDR *xdrs, guestfs_initrd_cat_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->initrdpath, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->filename, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_initrd_cat_ret (XDR *xdrs, guestfs_initrd_cat_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bytes (xdrs, (char **)&objp->content.content_val, (u_int *) &objp->content.content_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_initrd_list_args (XDR *xdrs, guestfs_initrd_list_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_initrd_list_ret (XDR *xdrs, guestfs_initrd_list_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->filenames.filenames_val, (u_int *) &objp->filenames.filenames_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inotify_add_watch_args (XDR *xdrs, guestfs_inotify_add_watch_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mask))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inotify_add_watch_ret (XDR *xdrs, guestfs_inotify_add_watch_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->wd))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inotify_files_ret (XDR *xdrs, guestfs_inotify_files_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->paths.paths_val, (u_int *) &objp->paths.paths_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inotify_init_args (XDR *xdrs, guestfs_inotify_init_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->maxevents))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inotify_read_ret (XDR *xdrs, guestfs_inotify_read_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_inotify_event_list (xdrs, &objp->events))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inotify_rm_watch_args (XDR *xdrs, guestfs_inotify_rm_watch_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->wd))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_arch_args (XDR *xdrs, guestfs_inspect_get_arch_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_arch_ret (XDR *xdrs, guestfs_inspect_get_arch_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->arch, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_distro_args (XDR *xdrs, guestfs_inspect_get_distro_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_distro_ret (XDR *xdrs, guestfs_inspect_get_distro_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->distro, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_drive_mappings_args (XDR *xdrs, guestfs_inspect_get_drive_mappings_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_drive_mappings_ret (XDR *xdrs, guestfs_inspect_get_drive_mappings_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->drives.drives_val, (u_int *) &objp->drives.drives_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_filesystems_args (XDR *xdrs, guestfs_inspect_get_filesystems_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_filesystems_ret (XDR *xdrs, guestfs_inspect_get_filesystems_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->filesystems.filesystems_val, (u_int *) &objp->filesystems.filesystems_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_format_args (XDR *xdrs, guestfs_inspect_get_format_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_format_ret (XDR *xdrs, guestfs_inspect_get_format_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->format, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_hostname_args (XDR *xdrs, guestfs_inspect_get_hostname_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_hostname_ret (XDR *xdrs, guestfs_inspect_get_hostname_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->hostname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_major_version_args (XDR *xdrs, guestfs_inspect_get_major_version_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_major_version_ret (XDR *xdrs, guestfs_inspect_get_major_version_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->major))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_minor_version_args (XDR *xdrs, guestfs_inspect_get_minor_version_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_minor_version_ret (XDR *xdrs, guestfs_inspect_get_minor_version_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->minor))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_mountpoints_args (XDR *xdrs, guestfs_inspect_get_mountpoints_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_mountpoints_ret (XDR *xdrs, guestfs_inspect_get_mountpoints_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->mountpoints.mountpoints_val, (u_int *) &objp->mountpoints.mountpoints_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_package_format_args (XDR *xdrs, guestfs_inspect_get_package_format_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_package_format_ret (XDR *xdrs, guestfs_inspect_get_package_format_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->packageformat, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_package_management_args (XDR *xdrs, guestfs_inspect_get_package_management_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_package_management_ret (XDR *xdrs, guestfs_inspect_get_package_management_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->packagemanagement, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_product_name_args (XDR *xdrs, guestfs_inspect_get_product_name_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_product_name_ret (XDR *xdrs, guestfs_inspect_get_product_name_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->product, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_product_variant_args (XDR *xdrs, guestfs_inspect_get_product_variant_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_product_variant_ret (XDR *xdrs, guestfs_inspect_get_product_variant_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->variant, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_roots_ret (XDR *xdrs, guestfs_inspect_get_roots_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->roots.roots_val, (u_int *) &objp->roots.roots_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_type_args (XDR *xdrs, guestfs_inspect_get_type_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_type_ret (XDR *xdrs, guestfs_inspect_get_type_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_windows_current_control_set_args (XDR *xdrs, guestfs_inspect_get_windows_current_control_set_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_windows_current_control_set_ret (XDR *xdrs, guestfs_inspect_get_windows_current_control_set_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->controlset, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_windows_software_hive_args (XDR *xdrs, guestfs_inspect_get_windows_software_hive_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_windows_software_hive_ret (XDR *xdrs, guestfs_inspect_get_windows_software_hive_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_windows_system_hive_args (XDR *xdrs, guestfs_inspect_get_windows_system_hive_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_windows_system_hive_ret (XDR *xdrs, guestfs_inspect_get_windows_system_hive_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_windows_systemroot_args (XDR *xdrs, guestfs_inspect_get_windows_systemroot_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_get_windows_systemroot_ret (XDR *xdrs, guestfs_inspect_get_windows_systemroot_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->systemroot, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_is_live_args (XDR *xdrs, guestfs_inspect_is_live_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_is_live_ret (XDR *xdrs, guestfs_inspect_is_live_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->live))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_is_multipart_args (XDR *xdrs, guestfs_inspect_is_multipart_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_is_multipart_ret (XDR *xdrs, guestfs_inspect_is_multipart_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->multipart))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_is_netinst_args (XDR *xdrs, guestfs_inspect_is_netinst_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->root, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_is_netinst_ret (XDR *xdrs, guestfs_inspect_is_netinst_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->netinst))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_inspect_os_ret (XDR *xdrs, guestfs_inspect_os_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->roots.roots_val, (u_int *) &objp->roots.roots_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_feature_available_args (XDR *xdrs, guestfs_internal_feature_available_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->group, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_feature_available_ret (XDR *xdrs, guestfs_internal_feature_available_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->result))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_filesystem_walk_args (XDR *xdrs, guestfs_internal_filesystem_walk_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_find_inode_args (XDR *xdrs, guestfs_internal_find_inode_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->inode))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_hot_add_drive_args (XDR *xdrs, guestfs_internal_hot_add_drive_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_hot_remove_drive_args (XDR *xdrs, guestfs_internal_hot_remove_drive_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_hot_remove_drive_precheck_args (XDR *xdrs, guestfs_internal_hot_remove_drive_precheck_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_list_rpm_applications_ret (XDR *xdrs, guestfs_internal_list_rpm_applications_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_application2_list (xdrs, &objp->applications2))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_lstatnslist_args (XDR *xdrs, guestfs_internal_lstatnslist_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->names.names_val, (u_int *) &objp->names.names_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_lstatnslist_ret (XDR *xdrs, guestfs_internal_lstatnslist_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_statns_list (xdrs, &objp->statbufs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_lxattrlist_args (XDR *xdrs, guestfs_internal_lxattrlist_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->names.names_val, (u_int *) &objp->names.names_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_lxattrlist_ret (XDR *xdrs, guestfs_internal_lxattrlist_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_xattr_list (xdrs, &objp->xattrs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_parse_mountable_args (XDR *xdrs, guestfs_internal_parse_mountable_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_parse_mountable_ret (XDR *xdrs, guestfs_internal_parse_mountable_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_internal_mountable (xdrs, &objp->mountable))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_readlinklist_args (XDR *xdrs, guestfs_internal_readlinklist_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->names.names_val, (u_int *) &objp->names.names_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_readlinklist_ret (XDR *xdrs, guestfs_internal_readlinklist_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->links.links_val, (u_int *) &objp->links.links_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_rhbz914931_args (XDR *xdrs, guestfs_internal_rhbz914931_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->count))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_upload_args (XDR *xdrs, guestfs_internal_upload_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->tmpname, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mode))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_write_args (XDR *xdrs, guestfs_internal_write_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bytes (xdrs, (char **)&objp->content.content_val, (u_int *) &objp->content.content_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_write_append_args (XDR *xdrs, guestfs_internal_write_append_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bytes (xdrs, (char **)&objp->content.content_val, (u_int *) &objp->content.content_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_internal_yara_scan_args (XDR *xdrs, guestfs_internal_yara_scan_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_blockdev_args (XDR *xdrs, guestfs_is_blockdev_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->followsymlinks))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_blockdev_ret (XDR *xdrs, guestfs_is_blockdev_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->flag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_chardev_args (XDR *xdrs, guestfs_is_chardev_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->followsymlinks))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_chardev_ret (XDR *xdrs, guestfs_is_chardev_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->flag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_dir_args (XDR *xdrs, guestfs_is_dir_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->followsymlinks))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_dir_ret (XDR *xdrs, guestfs_is_dir_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->dirflag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_fifo_args (XDR *xdrs, guestfs_is_fifo_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->followsymlinks))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_fifo_ret (XDR *xdrs, guestfs_is_fifo_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->flag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_file_args (XDR *xdrs, guestfs_is_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->followsymlinks))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_file_ret (XDR *xdrs, guestfs_is_file_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->fileflag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_lv_args (XDR *xdrs, guestfs_is_lv_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_lv_ret (XDR *xdrs, guestfs_is_lv_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->lvflag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_socket_args (XDR *xdrs, guestfs_is_socket_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->followsymlinks))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_socket_ret (XDR *xdrs, guestfs_is_socket_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->flag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_symlink_args (XDR *xdrs, guestfs_is_symlink_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_symlink_ret (XDR *xdrs, guestfs_is_symlink_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->flag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_whole_device_args (XDR *xdrs, guestfs_is_whole_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_whole_device_ret (XDR *xdrs, guestfs_is_whole_device_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->flag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_zero_args (XDR *xdrs, guestfs_is_zero_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_zero_ret (XDR *xdrs, guestfs_is_zero_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->zeroflag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_zero_device_args (XDR *xdrs, guestfs_is_zero_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_is_zero_device_ret (XDR *xdrs, guestfs_is_zero_device_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->zeroflag))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_isoinfo_args (XDR *xdrs, guestfs_isoinfo_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->isofile, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_isoinfo_ret (XDR *xdrs, guestfs_isoinfo_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_isoinfo (xdrs, &objp->isodata))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_isoinfo_device_args (XDR *xdrs, guestfs_isoinfo_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_isoinfo_device_ret (XDR *xdrs, guestfs_isoinfo_device_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_isoinfo (xdrs, &objp->isodata))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_journal_get_data_threshold_ret (XDR *xdrs, guestfs_journal_get_data_threshold_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->threshold))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_journal_get_realtime_usec_ret (XDR *xdrs, guestfs_journal_get_realtime_usec_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->usec))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_journal_next_ret (XDR *xdrs, guestfs_journal_next_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->more))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_journal_open_args (XDR *xdrs, guestfs_journal_open_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_journal_set_data_threshold_args (XDR *xdrs, guestfs_journal_set_data_threshold_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->threshold))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_journal_skip_args (XDR *xdrs, guestfs_journal_skip_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->skip))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_journal_skip_ret (XDR *xdrs, guestfs_journal_skip_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->rskip))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lchown_args (XDR *xdrs, guestfs_lchown_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->owner))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->group))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_diskgroup_disks_args (XDR *xdrs, guestfs_ldmtool_diskgroup_disks_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->diskgroup, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_diskgroup_disks_ret (XDR *xdrs, guestfs_ldmtool_diskgroup_disks_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->disks.disks_val, (u_int *) &objp->disks.disks_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_diskgroup_name_args (XDR *xdrs, guestfs_ldmtool_diskgroup_name_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->diskgroup, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_diskgroup_name_ret (XDR *xdrs, guestfs_ldmtool_diskgroup_name_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_diskgroup_volumes_args (XDR *xdrs, guestfs_ldmtool_diskgroup_volumes_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->diskgroup, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_diskgroup_volumes_ret (XDR *xdrs, guestfs_ldmtool_diskgroup_volumes_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->volumes.volumes_val, (u_int *) &objp->volumes.volumes_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_scan_ret (XDR *xdrs, guestfs_ldmtool_scan_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guids.guids_val, (u_int *) &objp->guids.guids_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_scan_devices_args (XDR *xdrs, guestfs_ldmtool_scan_devices_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_scan_devices_ret (XDR *xdrs, guestfs_ldmtool_scan_devices_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->guids.guids_val, (u_int *) &objp->guids.guids_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_volume_hint_args (XDR *xdrs, guestfs_ldmtool_volume_hint_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->diskgroup, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->volume, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_volume_hint_ret (XDR *xdrs, guestfs_ldmtool_volume_hint_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->hint, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_volume_partitions_args (XDR *xdrs, guestfs_ldmtool_volume_partitions_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->diskgroup, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->volume, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_volume_partitions_ret (XDR *xdrs, guestfs_ldmtool_volume_partitions_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->partitions.partitions_val, (u_int *) &objp->partitions.partitions_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_volume_type_args (XDR *xdrs, guestfs_ldmtool_volume_type_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->diskgroup, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->volume, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ldmtool_volume_type_ret (XDR *xdrs, guestfs_ldmtool_volume_type_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->voltype, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lgetxattr_args (XDR *xdrs, guestfs_lgetxattr_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lgetxattr_ret (XDR *xdrs, guestfs_lgetxattr_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bytes (xdrs, (char **)&objp->xattr.xattr_val, (u_int *) &objp->xattr.xattr_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lgetxattrs_args (XDR *xdrs, guestfs_lgetxattrs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lgetxattrs_ret (XDR *xdrs, guestfs_lgetxattrs_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_xattr_list (xdrs, &objp->xattrs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_9p_ret (XDR *xdrs, guestfs_list_9p_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->mounttags.mounttags_val, (u_int *) &objp->mounttags.mounttags_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_devices_ret (XDR *xdrs, guestfs_list_devices_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_disk_labels_ret (XDR *xdrs, guestfs_list_disk_labels_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->labels.labels_val, (u_int *) &objp->labels.labels_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_dm_devices_ret (XDR *xdrs, guestfs_list_dm_devices_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_filesystems_ret (XDR *xdrs, guestfs_list_filesystems_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->fses.fses_val, (u_int *) &objp->fses.fses_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_ldm_partitions_ret (XDR *xdrs, guestfs_list_ldm_partitions_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_ldm_volumes_ret (XDR *xdrs, guestfs_list_ldm_volumes_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_md_devices_ret (XDR *xdrs, guestfs_list_md_devices_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_list_partitions_ret (XDR *xdrs, guestfs_list_partitions_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->partitions.partitions_val, (u_int *) &objp->partitions.partitions_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ll_args (XDR *xdrs, guestfs_ll_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ll_ret (XDR *xdrs, guestfs_ll_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->listing, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_llz_args (XDR *xdrs, guestfs_llz_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_llz_ret (XDR *xdrs, guestfs_llz_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->listing, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ln_args (XDR *xdrs, guestfs_ln_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->target, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->linkname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ln_f_args (XDR *xdrs, guestfs_ln_f_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->target, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->linkname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ln_s_args (XDR *xdrs, guestfs_ln_s_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->target, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->linkname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ln_sf_args (XDR *xdrs, guestfs_ln_sf_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->target, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->linkname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lremovexattr_args (XDR *xdrs, guestfs_lremovexattr_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->xattr, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ls0_args (XDR *xdrs, guestfs_ls0_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->dir, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lsetxattr_args (XDR *xdrs, guestfs_lsetxattr_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->xattr, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->val, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->vallen))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lstatns_args (XDR *xdrs, guestfs_lstatns_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lstatns_ret (XDR *xdrs, guestfs_lstatns_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_statns (xdrs, &objp->statbuf))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_add_key_args (XDR *xdrs, guestfs_luks_add_key_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->newkey, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->keyslot))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_close_args (XDR *xdrs, guestfs_luks_close_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_format_args (XDR *xdrs, guestfs_luks_format_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->keyslot))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_format_cipher_args (XDR *xdrs, guestfs_luks_format_cipher_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->keyslot))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->cipher, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_kill_slot_args (XDR *xdrs, guestfs_luks_kill_slot_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->keyslot))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_open_args (XDR *xdrs, guestfs_luks_open_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mapname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_open_ro_args (XDR *xdrs, guestfs_luks_open_ro_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->key, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mapname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_uuid_args (XDR *xdrs, guestfs_luks_uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_luks_uuid_ret (XDR *xdrs, guestfs_luks_uuid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvcreate_args (XDR *xdrs, guestfs_lvcreate_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->logvol, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->volgroup, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mbytes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvcreate_free_args (XDR *xdrs, guestfs_lvcreate_free_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->logvol, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->volgroup, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->percent))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvm_canonical_lv_name_args (XDR *xdrs, guestfs_lvm_canonical_lv_name_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->lvname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvm_canonical_lv_name_ret (XDR *xdrs, guestfs_lvm_canonical_lv_name_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->lv, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvm_scan_args (XDR *xdrs, guestfs_lvm_scan_args *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->activate))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvm_set_filter_args (XDR *xdrs, guestfs_lvm_set_filter_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvremove_args (XDR *xdrs, guestfs_lvremove_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvrename_args (XDR *xdrs, guestfs_lvrename_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->logvol, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->newlogvol, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvresize_args (XDR *xdrs, guestfs_lvresize_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mbytes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvresize_free_args (XDR *xdrs, guestfs_lvresize_free_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->lv, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->percent))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvs_ret (XDR *xdrs, guestfs_lvs_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->logvols.logvols_val, (u_int *) &objp->logvols.logvols_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvs_full_ret (XDR *xdrs, guestfs_lvs_full_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_lvm_lv_list (xdrs, &objp->logvols))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvuuid_args (XDR *xdrs, guestfs_lvuuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_lvuuid_ret (XDR *xdrs, guestfs_lvuuid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_md_create_args (XDR *xdrs, guestfs_md_create_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->missingbitmap))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->nrdevices))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->spare))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->chunk))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->level, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_md_detail_args (XDR *xdrs, guestfs_md_detail_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->md, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_md_detail_ret (XDR *xdrs, guestfs_md_detail_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->info.info_val, (u_int *) &objp->info.info_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_md_stat_args (XDR *xdrs, guestfs_md_stat_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->md, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_md_stat_ret (XDR *xdrs, guestfs_md_stat_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_mdstat_list (xdrs, &objp->devices))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_md_stop_args (XDR *xdrs, guestfs_md_stop_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->md, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkdir_args (XDR *xdrs, guestfs_mkdir_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkdir_mode_args (XDR *xdrs, guestfs_mkdir_mode_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mode))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkdir_p_args (XDR *xdrs, guestfs_mkdir_p_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkdtemp_args (XDR *xdrs, guestfs_mkdtemp_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->tmpl, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkdtemp_ret (XDR *xdrs, guestfs_mkdtemp_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->dir, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mke2fs_args (XDR *xdrs, guestfs_mke2fs_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->blockscount))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->blocksize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->fragsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->blockspergroup))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->numberofgroups))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->bytesperinode))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->inodesize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->journalsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->numberofinodes))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->stridesize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->stripewidth))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->maxonlineresize))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->reservedblockspercentage))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->mmpupdateinterval))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->journaldevice, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->label, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->lastmounteddir, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->creatoros, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->fstype, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->usagetype, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->uuid, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 17 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->forcecreate))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->writesbandgrouponly))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->lazyitableinit))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->lazyjournalinit))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->testfs))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->discard))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->quotatype))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->extent))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->filetype))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->flexbg))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->hasjournal))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->journaldev))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->largefile))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->quota))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->resizeinode))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->sparsesuper))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->uninitbg))
				 return FALSE;
		} else {
			IXDR_PUT_BOOL(buf, objp->forcecreate);
			IXDR_PUT_BOOL(buf, objp->writesbandgrouponly);
			IXDR_PUT_BOOL(buf, objp->lazyitableinit);
			IXDR_PUT_BOOL(buf, objp->lazyjournalinit);
			IXDR_PUT_BOOL(buf, objp->testfs);
			IXDR_PUT_BOOL(buf, objp->discard);
			IXDR_PUT_BOOL(buf, objp->quotatype);
			IXDR_PUT_BOOL(buf, objp->extent);
			IXDR_PUT_BOOL(buf, objp->filetype);
			IXDR_PUT_BOOL(buf, objp->flexbg);
			IXDR_PUT_BOOL(buf, objp->hasjournal);
			IXDR_PUT_BOOL(buf, objp->journaldev);
			IXDR_PUT_BOOL(buf, objp->largefile);
			IXDR_PUT_BOOL(buf, objp->quota);
			IXDR_PUT_BOOL(buf, objp->resizeinode);
			IXDR_PUT_BOOL(buf, objp->sparsesuper);
			IXDR_PUT_BOOL(buf, objp->uninitbg);
		}
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->blockscount))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->blocksize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->fragsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->blockspergroup))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->numberofgroups))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->bytesperinode))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->inodesize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->journalsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->numberofinodes))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->stridesize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->stripewidth))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->maxonlineresize))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->reservedblockspercentage))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->mmpupdateinterval))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->journaldevice, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->label, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->lastmounteddir, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->creatoros, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->fstype, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->usagetype, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->uuid, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 17 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->forcecreate))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->writesbandgrouponly))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->lazyitableinit))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->lazyjournalinit))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->testfs))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->discard))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->quotatype))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->extent))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->filetype))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->flexbg))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->hasjournal))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->journaldev))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->largefile))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->quota))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->resizeinode))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->sparsesuper))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->uninitbg))
				 return FALSE;
		} else {
			objp->forcecreate = IXDR_GET_BOOL(buf);
			objp->writesbandgrouponly = IXDR_GET_BOOL(buf);
			objp->lazyitableinit = IXDR_GET_BOOL(buf);
			objp->lazyjournalinit = IXDR_GET_BOOL(buf);
			objp->testfs = IXDR_GET_BOOL(buf);
			objp->discard = IXDR_GET_BOOL(buf);
			objp->quotatype = IXDR_GET_BOOL(buf);
			objp->extent = IXDR_GET_BOOL(buf);
			objp->filetype = IXDR_GET_BOOL(buf);
			objp->flexbg = IXDR_GET_BOOL(buf);
			objp->hasjournal = IXDR_GET_BOOL(buf);
			objp->journaldev = IXDR_GET_BOOL(buf);
			objp->largefile = IXDR_GET_BOOL(buf);
			objp->quota = IXDR_GET_BOOL(buf);
			objp->resizeinode = IXDR_GET_BOOL(buf);
			objp->sparsesuper = IXDR_GET_BOOL(buf);
			objp->uninitbg = IXDR_GET_BOOL(buf);
		}
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->blockscount))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->fragsize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->blockspergroup))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->numberofgroups))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->bytesperinode))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->inodesize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->journalsize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->numberofinodes))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->stridesize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->stripewidth))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->maxonlineresize))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->reservedblockspercentage))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mmpupdateinterval))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->journaldevice, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->lastmounteddir, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->creatoros, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->fstype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->usagetype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->forcecreate))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->writesbandgrouponly))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->lazyitableinit))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->lazyjournalinit))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->testfs))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->discard))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->quotatype))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->extent))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->filetype))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->flexbg))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->hasjournal))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->journaldev))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->largefile))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->quota))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->resizeinode))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->sparsesuper))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->uninitbg))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mke2fs_J_args (XDR *xdrs, guestfs_mke2fs_J_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fstype, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->journal, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mke2fs_JL_args (XDR *xdrs, guestfs_mke2fs_JL_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fstype, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mke2fs_JU_args (XDR *xdrs, guestfs_mke2fs_JU_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fstype, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mke2journal_args (XDR *xdrs, guestfs_mke2journal_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mke2journal_L_args (XDR *xdrs, guestfs_mke2journal_L_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mke2journal_U_args (XDR *xdrs, guestfs_mke2journal_U_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkfifo_args (XDR *xdrs, guestfs_mkfifo_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->mode))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkfs_args (XDR *xdrs, guestfs_mkfs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fstype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->features, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->inode))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->sectorsize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkfs_b_args (XDR *xdrs, guestfs_mkfs_b_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fstype, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->blocksize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkfs_btrfs_args (XDR *xdrs, guestfs_mkfs_btrfs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->allocstart))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->bytecount))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->datatype, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->leafsize))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->metadata, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->nodesize))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->sectorsize))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mklost_and_found_args (XDR *xdrs, guestfs_mklost_and_found_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkmountpoint_args (XDR *xdrs, guestfs_mkmountpoint_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->exemptpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mknod_args (XDR *xdrs, guestfs_mknod_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->mode))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devmajor))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devminor))
				 return FALSE;

		} else {
		IXDR_PUT_LONG(buf, objp->mode);
		IXDR_PUT_LONG(buf, objp->devmajor);
		IXDR_PUT_LONG(buf, objp->devminor);
		}
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->mode))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devmajor))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devminor))
				 return FALSE;

		} else {
		objp->mode = IXDR_GET_LONG(buf);
		objp->devmajor = IXDR_GET_LONG(buf);
		objp->devminor = IXDR_GET_LONG(buf);
		}
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_int (xdrs, &objp->mode))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->devmajor))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->devminor))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mknod_b_args (XDR *xdrs, guestfs_mknod_b_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->mode))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devmajor))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devminor))
				 return FALSE;

		} else {
		IXDR_PUT_LONG(buf, objp->mode);
		IXDR_PUT_LONG(buf, objp->devmajor);
		IXDR_PUT_LONG(buf, objp->devminor);
		}
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->mode))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devmajor))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devminor))
				 return FALSE;

		} else {
		objp->mode = IXDR_GET_LONG(buf);
		objp->devmajor = IXDR_GET_LONG(buf);
		objp->devminor = IXDR_GET_LONG(buf);
		}
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_int (xdrs, &objp->mode))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->devmajor))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->devminor))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mknod_c_args (XDR *xdrs, guestfs_mknod_c_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->mode))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devmajor))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devminor))
				 return FALSE;

		} else {
		IXDR_PUT_LONG(buf, objp->mode);
		IXDR_PUT_LONG(buf, objp->devmajor);
		IXDR_PUT_LONG(buf, objp->devminor);
		}
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->mode))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devmajor))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->devminor))
				 return FALSE;

		} else {
		objp->mode = IXDR_GET_LONG(buf);
		objp->devmajor = IXDR_GET_LONG(buf);
		objp->devminor = IXDR_GET_LONG(buf);
		}
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_int (xdrs, &objp->mode))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->devmajor))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->devminor))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mksquashfs_args (XDR *xdrs, guestfs_mksquashfs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->compress, ~0))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->excludes.excludes_val, (u_int *) &objp->excludes.excludes_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkswap_args (XDR *xdrs, guestfs_mkswap_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkswap_L_args (XDR *xdrs, guestfs_mkswap_L_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkswap_U_args (XDR *xdrs, guestfs_mkswap_U_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mkswap_file_args (XDR *xdrs, guestfs_mkswap_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mktemp_args (XDR *xdrs, guestfs_mktemp_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->tmpl, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->suffix, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mktemp_ret (XDR *xdrs, guestfs_mktemp_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_modprobe_args (XDR *xdrs, guestfs_modprobe_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->modulename, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mount_args (XDR *xdrs, guestfs_mount_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mount_9p_args (XDR *xdrs, guestfs_mount_9p_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mounttag, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->options, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mount_loop_args (XDR *xdrs, guestfs_mount_loop_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mount_options_args (XDR *xdrs, guestfs_mount_options_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->options, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mount_ro_args (XDR *xdrs, guestfs_mount_ro_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mount_vfs_args (XDR *xdrs, guestfs_mount_vfs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->options, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->vfstype, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mountpoints_ret (XDR *xdrs, guestfs_mountpoints_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->mps.mps_val, (u_int *) &objp->mps.mps_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mounts_ret (XDR *xdrs, guestfs_mounts_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_mv_args (XDR *xdrs, guestfs_mv_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_nr_devices_ret (XDR *xdrs, guestfs_nr_devices_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->nrdisks))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ntfs_3g_probe_args (XDR *xdrs, guestfs_ntfs_3g_probe_args *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->rw))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ntfs_3g_probe_ret (XDR *xdrs, guestfs_ntfs_3g_probe_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->status))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ntfscat_i_args (XDR *xdrs, guestfs_ntfscat_i_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->inode))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ntfsclone_in_args (XDR *xdrs, guestfs_ntfsclone_in_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ntfsclone_out_args (XDR *xdrs, guestfs_ntfsclone_out_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->metadataonly))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->rescue))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->ignorefscheck))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->preservetimestamps))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->force))
				 return FALSE;
		} else {
			IXDR_PUT_BOOL(buf, objp->metadataonly);
			IXDR_PUT_BOOL(buf, objp->rescue);
			IXDR_PUT_BOOL(buf, objp->ignorefscheck);
			IXDR_PUT_BOOL(buf, objp->preservetimestamps);
			IXDR_PUT_BOOL(buf, objp->force);
		}
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->metadataonly))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->rescue))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->ignorefscheck))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->preservetimestamps))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->force))
				 return FALSE;
		} else {
			objp->metadataonly = IXDR_GET_BOOL(buf);
			objp->rescue = IXDR_GET_BOOL(buf);
			objp->ignorefscheck = IXDR_GET_BOOL(buf);
			objp->preservetimestamps = IXDR_GET_BOOL(buf);
			objp->force = IXDR_GET_BOOL(buf);
		}
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->metadataonly))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->rescue))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->ignorefscheck))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->preservetimestamps))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->force))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ntfsfix_args (XDR *xdrs, guestfs_ntfsfix_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->clearbadsectors))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ntfsresize_args (XDR *xdrs, guestfs_ntfsresize_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->force))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_ntfsresize_size_args (XDR *xdrs, guestfs_ntfsresize_size_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_add_args (XDR *xdrs, guestfs_part_add_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->prlogex, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->startsect))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->endsect))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_del_args (XDR *xdrs, guestfs_part_del_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_disk_args (XDR *xdrs, guestfs_part_disk_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->parttype, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_expand_gpt_args (XDR *xdrs, guestfs_part_expand_gpt_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_bootable_args (XDR *xdrs, guestfs_part_get_bootable_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_bootable_ret (XDR *xdrs, guestfs_part_get_bootable_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->bootable))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_disk_guid_args (XDR *xdrs, guestfs_part_get_disk_guid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_disk_guid_ret (XDR *xdrs, guestfs_part_get_disk_guid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->guid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_gpt_attributes_args (XDR *xdrs, guestfs_part_get_gpt_attributes_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_gpt_attributes_ret (XDR *xdrs, guestfs_part_get_gpt_attributes_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->attributes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_gpt_guid_args (XDR *xdrs, guestfs_part_get_gpt_guid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_gpt_guid_ret (XDR *xdrs, guestfs_part_get_gpt_guid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->guid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_gpt_type_args (XDR *xdrs, guestfs_part_get_gpt_type_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_gpt_type_ret (XDR *xdrs, guestfs_part_get_gpt_type_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->guid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_mbr_id_args (XDR *xdrs, guestfs_part_get_mbr_id_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_mbr_id_ret (XDR *xdrs, guestfs_part_get_mbr_id_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->idbyte))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_mbr_part_type_args (XDR *xdrs, guestfs_part_get_mbr_part_type_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_mbr_part_type_ret (XDR *xdrs, guestfs_part_get_mbr_part_type_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->partitiontype, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_name_args (XDR *xdrs, guestfs_part_get_name_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_name_ret (XDR *xdrs, guestfs_part_get_name_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_parttype_args (XDR *xdrs, guestfs_part_get_parttype_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_get_parttype_ret (XDR *xdrs, guestfs_part_get_parttype_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->parttype, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_init_args (XDR *xdrs, guestfs_part_init_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->parttype, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_list_args (XDR *xdrs, guestfs_part_list_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_list_ret (XDR *xdrs, guestfs_part_list_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_partition_list (xdrs, &objp->partitions))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_resize_args (XDR *xdrs, guestfs_part_resize_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->endsect))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_set_bootable_args (XDR *xdrs, guestfs_part_set_bootable_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->bootable))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_set_disk_guid_args (XDR *xdrs, guestfs_part_set_disk_guid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->guid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_set_disk_guid_random_args (XDR *xdrs, guestfs_part_set_disk_guid_random_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_set_gpt_attributes_args (XDR *xdrs, guestfs_part_set_gpt_attributes_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->attributes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_set_gpt_guid_args (XDR *xdrs, guestfs_part_set_gpt_guid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->guid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_set_gpt_type_args (XDR *xdrs, guestfs_part_set_gpt_type_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->guid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_set_mbr_id_args (XDR *xdrs, guestfs_part_set_mbr_id_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->idbyte))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_set_name_args (XDR *xdrs, guestfs_part_set_name_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->name, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_to_dev_args (XDR *xdrs, guestfs_part_to_dev_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->partition, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_to_dev_ret (XDR *xdrs, guestfs_part_to_dev_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_to_partnum_args (XDR *xdrs, guestfs_part_to_partnum_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->partition, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_part_to_partnum_ret (XDR *xdrs, guestfs_part_to_partnum_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pread_args (XDR *xdrs, guestfs_pread_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->offset))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pread_ret (XDR *xdrs, guestfs_pread_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bytes (xdrs, (char **)&objp->content.content_val, (u_int *) &objp->content.content_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pread_device_args (XDR *xdrs, guestfs_pread_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->count))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->offset))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pread_device_ret (XDR *xdrs, guestfs_pread_device_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bytes (xdrs, (char **)&objp->content.content_val, (u_int *) &objp->content.content_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvchange_uuid_args (XDR *xdrs, guestfs_pvchange_uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvcreate_args (XDR *xdrs, guestfs_pvcreate_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvremove_args (XDR *xdrs, guestfs_pvremove_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvresize_args (XDR *xdrs, guestfs_pvresize_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvresize_size_args (XDR *xdrs, guestfs_pvresize_size_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvs_ret (XDR *xdrs, guestfs_pvs_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->physvols.physvols_val, (u_int *) &objp->physvols.physvols_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvs_full_ret (XDR *xdrs, guestfs_pvs_full_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_lvm_pv_list (xdrs, &objp->physvols))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvuuid_args (XDR *xdrs, guestfs_pvuuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pvuuid_ret (XDR *xdrs, guestfs_pvuuid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pwrite_args (XDR *xdrs, guestfs_pwrite_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bytes (xdrs, (char **)&objp->content.content_val, (u_int *) &objp->content.content_len, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->offset))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pwrite_ret (XDR *xdrs, guestfs_pwrite_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->nbytes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pwrite_device_args (XDR *xdrs, guestfs_pwrite_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bytes (xdrs, (char **)&objp->content.content_val, (u_int *) &objp->content.content_len, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->offset))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_pwrite_device_ret (XDR *xdrs, guestfs_pwrite_device_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->nbytes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_readdir_args (XDR *xdrs, guestfs_readdir_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->dir, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_readdir_ret (XDR *xdrs, guestfs_readdir_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_dirent_list (xdrs, &objp->entries))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_readlink_args (XDR *xdrs, guestfs_readlink_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_readlink_ret (XDR *xdrs, guestfs_readlink_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->link, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_realpath_args (XDR *xdrs, guestfs_realpath_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_realpath_ret (XDR *xdrs, guestfs_realpath_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->rpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_remount_args (XDR *xdrs, guestfs_remount_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountpoint, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->rw))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_removexattr_args (XDR *xdrs, guestfs_removexattr_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->xattr, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rename_args (XDR *xdrs, guestfs_rename_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->oldpath, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->newpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_resize2fs_args (XDR *xdrs, guestfs_resize2fs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_resize2fs_M_args (XDR *xdrs, guestfs_resize2fs_M_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_resize2fs_size_args (XDR *xdrs, guestfs_resize2fs_size_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rm_args (XDR *xdrs, guestfs_rm_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rm_f_args (XDR *xdrs, guestfs_rm_f_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rm_rf_args (XDR *xdrs, guestfs_rm_rf_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rmdir_args (XDR *xdrs, guestfs_rmdir_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rmmountpoint_args (XDR *xdrs, guestfs_rmmountpoint_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->exemptpath, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rsync_args (XDR *xdrs, guestfs_rsync_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->archive))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->deletedest))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rsync_in_args (XDR *xdrs, guestfs_rsync_in_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->remote, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->dest, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->archive))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->deletedest))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_rsync_out_args (XDR *xdrs, guestfs_rsync_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->src, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->remote, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->archive))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->deletedest))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_scrub_device_args (XDR *xdrs, guestfs_scrub_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_scrub_file_args (XDR *xdrs, guestfs_scrub_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_scrub_freespace_args (XDR *xdrs, guestfs_scrub_freespace_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->dir, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_selinux_relabel_args (XDR *xdrs, guestfs_selinux_relabel_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->specfile, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->force))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_set_e2attrs_args (XDR *xdrs, guestfs_set_e2attrs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->attrs, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->clear))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_set_e2generation_args (XDR *xdrs, guestfs_set_e2generation_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->generation))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_set_e2label_args (XDR *xdrs, guestfs_set_e2label_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_set_e2uuid_args (XDR *xdrs, guestfs_set_e2uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_set_label_args (XDR *xdrs, guestfs_set_label_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_set_uuid_args (XDR *xdrs, guestfs_set_uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_set_uuid_random_args (XDR *xdrs, guestfs_set_uuid_random_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_setcon_args (XDR *xdrs, guestfs_setcon_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->context, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_setxattr_args (XDR *xdrs, guestfs_setxattr_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->xattr, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->val, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->vallen))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdisk_args (XDR *xdrs, guestfs_sfdisk_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->cyls))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->heads))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->sectors))
				 return FALSE;

		} else {
		IXDR_PUT_LONG(buf, objp->cyls);
		IXDR_PUT_LONG(buf, objp->heads);
		IXDR_PUT_LONG(buf, objp->sectors);
		}
		 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
			sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->cyls))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->heads))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->sectors))
				 return FALSE;

		} else {
		objp->cyls = IXDR_GET_LONG(buf);
		objp->heads = IXDR_GET_LONG(buf);
		objp->sectors = IXDR_GET_LONG(buf);
		}
		 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
			sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->cyls))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->heads))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->sectors))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdiskM_args (XDR *xdrs, guestfs_sfdiskM_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdisk_N_args (XDR *xdrs, guestfs_sfdisk_N_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->partnum))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->cyls))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->heads))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->sectors))
				 return FALSE;

		} else {
		IXDR_PUT_LONG(buf, objp->partnum);
		IXDR_PUT_LONG(buf, objp->cyls);
		IXDR_PUT_LONG(buf, objp->heads);
		IXDR_PUT_LONG(buf, objp->sectors);
		}
		 if (!xdr_string (xdrs, &objp->line, ~0))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_int (xdrs, &objp->partnum))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->cyls))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->heads))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->sectors))
				 return FALSE;

		} else {
		objp->partnum = IXDR_GET_LONG(buf);
		objp->cyls = IXDR_GET_LONG(buf);
		objp->heads = IXDR_GET_LONG(buf);
		objp->sectors = IXDR_GET_LONG(buf);
		}
		 if (!xdr_string (xdrs, &objp->line, ~0))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->partnum))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->cyls))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->heads))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->sectors))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->line, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdisk_disk_geometry_args (XDR *xdrs, guestfs_sfdisk_disk_geometry_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdisk_disk_geometry_ret (XDR *xdrs, guestfs_sfdisk_disk_geometry_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->partitions, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdisk_kernel_geometry_args (XDR *xdrs, guestfs_sfdisk_kernel_geometry_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdisk_kernel_geometry_ret (XDR *xdrs, guestfs_sfdisk_kernel_geometry_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->partitions, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdisk_l_args (XDR *xdrs, guestfs_sfdisk_l_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sfdisk_l_ret (XDR *xdrs, guestfs_sfdisk_l_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->partitions, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sh_args (XDR *xdrs, guestfs_sh_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->command, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sh_ret (XDR *xdrs, guestfs_sh_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->output, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sh_lines_args (XDR *xdrs, guestfs_sh_lines_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->command, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sh_lines_ret (XDR *xdrs, guestfs_sh_lines_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_sleep_args (XDR *xdrs, guestfs_sleep_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->secs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_statns_args (XDR *xdrs, guestfs_statns_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_statns_ret (XDR *xdrs, guestfs_statns_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_statns (xdrs, &objp->statbuf))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_statvfs_args (XDR *xdrs, guestfs_statvfs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_statvfs_ret (XDR *xdrs, guestfs_statvfs_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_statvfs (xdrs, &objp->statbuf))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_strings_args (XDR *xdrs, guestfs_strings_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_strings_ret (XDR *xdrs, guestfs_strings_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->stringsout.stringsout_val, (u_int *) &objp->stringsout.stringsout_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_strings_e_args (XDR *xdrs, guestfs_strings_e_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->encoding, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_strings_e_ret (XDR *xdrs, guestfs_strings_e_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->stringsout.stringsout_val, (u_int *) &objp->stringsout.stringsout_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_swapoff_device_args (XDR *xdrs, guestfs_swapoff_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_swapoff_file_args (XDR *xdrs, guestfs_swapoff_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_swapoff_label_args (XDR *xdrs, guestfs_swapoff_label_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_swapoff_uuid_args (XDR *xdrs, guestfs_swapoff_uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_swapon_device_args (XDR *xdrs, guestfs_swapon_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_swapon_file_args (XDR *xdrs, guestfs_swapon_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->file, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_swapon_label_args (XDR *xdrs, guestfs_swapon_label_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_swapon_uuid_args (XDR *xdrs, guestfs_swapon_uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_syslinux_args (XDR *xdrs, guestfs_syslinux_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tail_args (XDR *xdrs, guestfs_tail_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tail_ret (XDR *xdrs, guestfs_tail_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tail_n_args (XDR *xdrs, guestfs_tail_n_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->nrlines))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tail_n_ret (XDR *xdrs, guestfs_tail_n_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tar_in_args (XDR *xdrs, guestfs_tar_in_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->compress, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->xattrs))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->selinux))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->acls))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tar_out_args (XDR *xdrs, guestfs_tar_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->compress, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->numericowner))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->excludes.excludes_val, (u_int *) &objp->excludes.excludes_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->xattrs))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->selinux))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->acls))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tgz_in_args (XDR *xdrs, guestfs_tgz_in_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tgz_out_args (XDR *xdrs, guestfs_tgz_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_touch_args (XDR *xdrs, guestfs_touch_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_truncate_args (XDR *xdrs, guestfs_truncate_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_truncate_size_args (XDR *xdrs, guestfs_truncate_size_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tune2fs_args (XDR *xdrs, guestfs_tune2fs_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->force))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->maxmountcount))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->mountcount))
				 return FALSE;

		} else {
		IXDR_PUT_BOOL(buf, objp->force);
		IXDR_PUT_LONG(buf, objp->maxmountcount);
		IXDR_PUT_LONG(buf, objp->mountcount);
		}
		 if (!xdr_string (xdrs, &objp->errorbehavior, ~0))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->group))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->intervalbetweenchecks))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->reservedblockspercentage))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->lastmounteddirectory, ~0))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->reservedblockscount))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->user))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->force))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->maxmountcount))
				 return FALSE;
			 if (!xdr_int (xdrs, &objp->mountcount))
				 return FALSE;

		} else {
		objp->force = IXDR_GET_BOOL(buf);
		objp->maxmountcount = IXDR_GET_LONG(buf);
		objp->mountcount = IXDR_GET_LONG(buf);
		}
		 if (!xdr_string (xdrs, &objp->errorbehavior, ~0))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->group))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->intervalbetweenchecks))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->reservedblockspercentage))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->lastmounteddirectory, ~0))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->reservedblockscount))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->user))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->force))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->maxmountcount))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->mountcount))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->errorbehavior, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->group))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->intervalbetweenchecks))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->reservedblockspercentage))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->lastmounteddirectory, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->reservedblockscount))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->user))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tune2fs_l_args (XDR *xdrs, guestfs_tune2fs_l_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_tune2fs_l_ret (XDR *xdrs, guestfs_tune2fs_l_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->superblock.superblock_val, (u_int *) &objp->superblock.superblock_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_txz_in_args (XDR *xdrs, guestfs_txz_in_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_txz_out_args (XDR *xdrs, guestfs_txz_out_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_umask_args (XDR *xdrs, guestfs_umask_args *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->mask))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_umask_ret (XDR *xdrs, guestfs_umask_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->oldmask))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_umount_args (XDR *xdrs, guestfs_umount_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->pathordevice, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->force))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->lazyunmount))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_upload_args (XDR *xdrs, guestfs_upload_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->remotefilename, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_upload_offset_args (XDR *xdrs, guestfs_upload_offset_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->remotefilename, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->offset))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_utimens_args (XDR *xdrs, guestfs_utimens_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->atsecs))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->atnsecs))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->mtsecs))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->mtnsecs))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_utsname_ret (XDR *xdrs, guestfs_utsname_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_utsname (xdrs, &objp->uts))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vfs_label_args (XDR *xdrs, guestfs_vfs_label_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vfs_label_ret (XDR *xdrs, guestfs_vfs_label_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vfs_minimum_size_args (XDR *xdrs, guestfs_vfs_minimum_size_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vfs_minimum_size_ret (XDR *xdrs, guestfs_vfs_minimum_size_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int64_t (xdrs, &objp->sizeinbytes))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vfs_type_args (XDR *xdrs, guestfs_vfs_type_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vfs_type_ret (XDR *xdrs, guestfs_vfs_type_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->fstype, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vfs_uuid_args (XDR *xdrs, guestfs_vfs_uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->mountable, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vfs_uuid_ret (XDR *xdrs, guestfs_vfs_uuid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vg_activate_args (XDR *xdrs, guestfs_vg_activate_args *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->activate))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->volgroups.volgroups_val, (u_int *) &objp->volgroups.volgroups_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vg_activate_all_args (XDR *xdrs, guestfs_vg_activate_all_args *objp)
{
	register int32_t *buf;

	 if (!xdr_bool (xdrs, &objp->activate))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgchange_uuid_args (XDR *xdrs, guestfs_vgchange_uuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->vg, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgcreate_args (XDR *xdrs, guestfs_vgcreate_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->volgroup, ~0))
		 return FALSE;
	 if (!xdr_array (xdrs, (char **)&objp->physvols.physvols_val, (u_int *) &objp->physvols.physvols_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vglvuuids_args (XDR *xdrs, guestfs_vglvuuids_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->vgname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vglvuuids_ret (XDR *xdrs, guestfs_vglvuuids_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->uuids.uuids_val, (u_int *) &objp->uuids.uuids_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgmeta_args (XDR *xdrs, guestfs_vgmeta_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->vgname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgmeta_ret (XDR *xdrs, guestfs_vgmeta_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_bytes (xdrs, (char **)&objp->metadata.metadata_val, (u_int *) &objp->metadata.metadata_len, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgpvuuids_args (XDR *xdrs, guestfs_vgpvuuids_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->vgname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgpvuuids_ret (XDR *xdrs, guestfs_vgpvuuids_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->uuids.uuids_val, (u_int *) &objp->uuids.uuids_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgremove_args (XDR *xdrs, guestfs_vgremove_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->vgname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgrename_args (XDR *xdrs, guestfs_vgrename_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->volgroup, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->newvolgroup, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgs_ret (XDR *xdrs, guestfs_vgs_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->volgroups.volgroups_val, (u_int *) &objp->volgroups.volgroups_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vgs_full_ret (XDR *xdrs, guestfs_vgs_full_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_lvm_vg_list (xdrs, &objp->volgroups))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vguuid_args (XDR *xdrs, guestfs_vguuid_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->vgname, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_vguuid_ret (XDR *xdrs, guestfs_vguuid_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_wc_c_args (XDR *xdrs, guestfs_wc_c_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_wc_c_ret (XDR *xdrs, guestfs_wc_c_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->chars))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_wc_l_args (XDR *xdrs, guestfs_wc_l_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_wc_l_ret (XDR *xdrs, guestfs_wc_l_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->lines))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_wc_w_args (XDR *xdrs, guestfs_wc_w_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_wc_w_ret (XDR *xdrs, guestfs_wc_w_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->words))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_wipefs_args (XDR *xdrs, guestfs_wipefs_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_write_file_args (XDR *xdrs, guestfs_write_file_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->content, ~0))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->size))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_xfs_admin_args (XDR *xdrs, guestfs_xfs_admin_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->extunwritten))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->imgfile))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->v2log))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->projid32bit))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->lazycounter))
				 return FALSE;

		} else {
		IXDR_PUT_BOOL(buf, objp->extunwritten);
		IXDR_PUT_BOOL(buf, objp->imgfile);
		IXDR_PUT_BOOL(buf, objp->v2log);
		IXDR_PUT_BOOL(buf, objp->projid32bit);
		IXDR_PUT_BOOL(buf, objp->lazycounter);
		}
		 if (!xdr_string (xdrs, &objp->label, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->uuid, ~0))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->extunwritten))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->imgfile))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->v2log))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->projid32bit))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->lazycounter))
				 return FALSE;

		} else {
		objp->extunwritten = IXDR_GET_BOOL(buf);
		objp->imgfile = IXDR_GET_BOOL(buf);
		objp->v2log = IXDR_GET_BOOL(buf);
		objp->projid32bit = IXDR_GET_BOOL(buf);
		objp->lazycounter = IXDR_GET_BOOL(buf);
		}
		 if (!xdr_string (xdrs, &objp->label, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->uuid, ~0))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->extunwritten))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->imgfile))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->v2log))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->projid32bit))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->lazycounter))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->label, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->uuid, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_xfs_growfs_args (XDR *xdrs, guestfs_xfs_growfs_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->datasec))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->logsec))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->rtsec))
				 return FALSE;

		} else {
		IXDR_PUT_BOOL(buf, objp->datasec);
		IXDR_PUT_BOOL(buf, objp->logsec);
		IXDR_PUT_BOOL(buf, objp->rtsec);
		}
		 if (!xdr_int64_t (xdrs, &objp->datasize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->logsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->rtsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->rtextsize))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->maxpct))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->path, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->datasec))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->logsec))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->rtsec))
				 return FALSE;

		} else {
		objp->datasec = IXDR_GET_BOOL(buf);
		objp->logsec = IXDR_GET_BOOL(buf);
		objp->rtsec = IXDR_GET_BOOL(buf);
		}
		 if (!xdr_int64_t (xdrs, &objp->datasize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->logsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->rtsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->rtextsize))
			 return FALSE;
		 if (!xdr_int (xdrs, &objp->maxpct))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->datasec))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->logsec))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->rtsec))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->datasize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->logsize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->rtsize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->rtextsize))
		 return FALSE;
	 if (!xdr_int (xdrs, &objp->maxpct))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_xfs_info_args (XDR *xdrs, guestfs_xfs_info_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->pathordevice, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_xfs_info_ret (XDR *xdrs, guestfs_xfs_info_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_int_xfsinfo (xdrs, &objp->info))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_xfs_repair_args (XDR *xdrs, guestfs_xfs_repair_args *objp)
{
	register int32_t *buf;


	if (xdrs->x_op == XDR_ENCODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->forcelogzero))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->nomodify))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->noprefetch))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->forcegeometry))
				 return FALSE;

		} else {
		IXDR_PUT_BOOL(buf, objp->forcelogzero);
		IXDR_PUT_BOOL(buf, objp->nomodify);
		IXDR_PUT_BOOL(buf, objp->noprefetch);
		IXDR_PUT_BOOL(buf, objp->forcegeometry);
		}
		 if (!xdr_int64_t (xdrs, &objp->maxmem))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->ihashsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->bhashsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->agstride))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->logdev, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->rtdev, ~0))
			 return FALSE;
		return TRUE;
	} else if (xdrs->x_op == XDR_DECODE) {
		 if (!xdr_string (xdrs, &objp->device, ~0))
			 return FALSE;
		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
		if (buf == NULL) {
			 if (!xdr_bool (xdrs, &objp->forcelogzero))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->nomodify))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->noprefetch))
				 return FALSE;
			 if (!xdr_bool (xdrs, &objp->forcegeometry))
				 return FALSE;

		} else {
		objp->forcelogzero = IXDR_GET_BOOL(buf);
		objp->nomodify = IXDR_GET_BOOL(buf);
		objp->noprefetch = IXDR_GET_BOOL(buf);
		objp->forcegeometry = IXDR_GET_BOOL(buf);
		}
		 if (!xdr_int64_t (xdrs, &objp->maxmem))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->ihashsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->bhashsize))
			 return FALSE;
		 if (!xdr_int64_t (xdrs, &objp->agstride))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->logdev, ~0))
			 return FALSE;
		 if (!xdr_string (xdrs, &objp->rtdev, ~0))
			 return FALSE;
	 return TRUE;
	}

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->forcelogzero))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->nomodify))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->noprefetch))
		 return FALSE;
	 if (!xdr_bool (xdrs, &objp->forcegeometry))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->maxmem))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->ihashsize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->bhashsize))
		 return FALSE;
	 if (!xdr_int64_t (xdrs, &objp->agstride))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->logdev, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->rtdev, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_xfs_repair_ret (XDR *xdrs, guestfs_xfs_repair_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->status))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zegrep_args (XDR *xdrs, guestfs_zegrep_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->regex, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zegrep_ret (XDR *xdrs, guestfs_zegrep_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zegrepi_args (XDR *xdrs, guestfs_zegrepi_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->regex, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zegrepi_ret (XDR *xdrs, guestfs_zegrepi_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zero_args (XDR *xdrs, guestfs_zero_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zero_device_args (XDR *xdrs, guestfs_zero_device_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zero_free_space_args (XDR *xdrs, guestfs_zero_free_space_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->directory, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zerofree_args (XDR *xdrs, guestfs_zerofree_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->device, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zfgrep_args (XDR *xdrs, guestfs_zfgrep_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->pattern, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zfgrep_ret (XDR *xdrs, guestfs_zfgrep_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zfgrepi_args (XDR *xdrs, guestfs_zfgrepi_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->pattern, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zfgrepi_ret (XDR *xdrs, guestfs_zfgrepi_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zfile_args (XDR *xdrs, guestfs_zfile_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->meth, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zfile_ret (XDR *xdrs, guestfs_zfile_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->description, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zgrep_args (XDR *xdrs, guestfs_zgrep_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->regex, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zgrep_ret (XDR *xdrs, guestfs_zgrep_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zgrepi_args (XDR *xdrs, guestfs_zgrepi_args *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->regex, ~0))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->path, ~0))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_zgrepi_ret (XDR *xdrs, guestfs_zgrepi_ret *objp)
{
	register int32_t *buf;

	 if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
		sizeof (guestfs_str), (xdrproc_t) xdr_guestfs_str))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_procedure (XDR *xdrs, guestfs_procedure *objp)
{
	register int32_t *buf;

	 if (!xdr_enum (xdrs, (enum_t *) objp))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_message_direction (XDR *xdrs, guestfs_message_direction *objp)
{
	register int32_t *buf;

	 if (!xdr_enum (xdrs, (enum_t *) objp))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_message_status (XDR *xdrs, guestfs_message_status *objp)
{
	register int32_t *buf;

	 if (!xdr_enum (xdrs, (enum_t *) objp))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_message_error (XDR *xdrs, guestfs_message_error *objp)
{
	register int32_t *buf;

	 if (!xdr_string (xdrs, &objp->errno_string, 32))
		 return FALSE;
	 if (!xdr_string (xdrs, &objp->error_message, GUESTFS_ERROR_LEN))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_message_header (XDR *xdrs, guestfs_message_header *objp)
{
	register int32_t *buf;

	 if (!xdr_u_int (xdrs, &objp->prog))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->vers))
		 return FALSE;
	 if (!xdr_guestfs_procedure (xdrs, &objp->proc))
		 return FALSE;
	 if (!xdr_guestfs_message_direction (xdrs, &objp->direction))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->serial))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->progress_hint))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->optargs_bitmask))
		 return FALSE;
	 if (!xdr_guestfs_message_status (xdrs, &objp->status))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_chunk (XDR *xdrs, guestfs_chunk *objp)
{
	register int32_t *buf;

	 if (!xdr_int (xdrs, &objp->cancel))
		 return FALSE;
	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, GUESTFS_MAX_CHUNK_SIZE))
		 return FALSE;
	return TRUE;
}

bool_t
xdr_guestfs_progress (XDR *xdrs, guestfs_progress *objp)
{
	register int32_t *buf;

	 if (!xdr_guestfs_procedure (xdrs, &objp->proc))
		 return FALSE;
	 if (!xdr_u_int (xdrs, &objp->serial))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->position))
		 return FALSE;
	 if (!xdr_uint64_t (xdrs, &objp->total))
		 return FALSE;
	return TRUE;
}
