/* Machine generated file -- Do NOT edit */

#include "ptint.h"

#define PR_SF_ALLBITS 0xff /* set all access bits */
#define PR_SF_NGROUPS (1<<31) /* set field limiting group creation */
#define PR_SF_NUSERS (1<<30) /*  "  "  foreign users  "  */
static afs_int32 _PR_INewEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * name=(char *)0;
	afs_int32 id, oid;



	if ((!xdr_string(z_xdrs, &name, PR_MAXNAMELEN))
	     || (!xdr_afs_int32(z_xdrs, &id))
	     || (!xdr_afs_int32(z_xdrs, &oid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_INewEntry(z_call, name, id, oid);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, PR_MAXNAMELEN)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		0, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		0, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_WhereIsIt(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id;
	afs_int32 ps;




	if ((!xdr_afs_int32(z_xdrs, &id))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_WhereIsIt(z_call, id, &ps);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &ps)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		1, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_DumpEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 pos;
	struct prdebugentry entry;




	if ((!xdr_afs_int32(z_xdrs, &pos))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_DumpEntry(z_call, pos, &entry);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prdebugentry(z_xdrs, &entry)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		2, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_AddToGroup(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 uid, gid;




	if ((!xdr_afs_int32(z_xdrs, &uid))
	     || (!xdr_afs_int32(z_xdrs, &gid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_AddToGroup(z_call, uid, gid);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		3, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_NameToID(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	namelist nlist;
	idlist ilist;



	nlist.namelist_val = 0;
	nlist.namelist_len = 0;
	ilist.idlist_val = 0;
	ilist.idlist_len = 0;

	if ((!xdr_namelist(z_xdrs, &nlist))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_NameToID(z_call, &nlist, &ilist);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_idlist(z_xdrs, &ilist)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_namelist(z_xdrs, &nlist)) goto fail1;
	if (!xdr_idlist(z_xdrs, &ilist)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		4, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		4, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_IDToName(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	idlist ilist;
	namelist nlist;



	nlist.namelist_val = 0;
	nlist.namelist_len = 0;
	ilist.idlist_val = 0;
	ilist.idlist_len = 0;

	if ((!xdr_idlist(z_xdrs, &ilist))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_IDToName(z_call, &ilist, &nlist);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_namelist(z_xdrs, &nlist)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_idlist(z_xdrs, &ilist)) goto fail1;
	if (!xdr_namelist(z_xdrs, &nlist)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		5, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		5, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_Delete(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id;




	if ((!xdr_afs_int32(z_xdrs, &id))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_Delete(z_call, id);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		6, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_RemoveFromGroup(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id, gid;




	if ((!xdr_afs_int32(z_xdrs, &id))
	     || (!xdr_afs_int32(z_xdrs, &gid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_RemoveFromGroup(z_call, id, gid);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		7, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_GetCPS(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id;
	prlist elist;
	afs_int32 over;



	elist.prlist_val = 0;
	elist.prlist_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &id))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_GetCPS(z_call, id, &elist, &over);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prlist(z_xdrs, &elist))
	     || (!xdr_afs_int32(z_xdrs, &over)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_prlist(z_xdrs, &elist)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		8, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		8, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_NewEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * name=(char *)0;
	afs_int32 flag, oid;
	afs_int32 id;



	if ((!xdr_string(z_xdrs, &name, PR_MAXNAMELEN))
	     || (!xdr_afs_int32(z_xdrs, &flag))
	     || (!xdr_afs_int32(z_xdrs, &oid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_NewEntry(z_call, name, flag, oid, &id);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &id)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, PR_MAXNAMELEN)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		9, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		9, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_ListMax(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 uid, gid;



	z_result = SPR_ListMax(z_call, &uid, &gid);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &uid))
	     || (!xdr_afs_int32(z_xdrs, &gid)))
		z_result = RXGEN_SS_MARSHAL;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		10, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_SetMax(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id, gflag;




	if ((!xdr_afs_int32(z_xdrs, &id))
	     || (!xdr_afs_int32(z_xdrs, &gflag))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_SetMax(z_call, id, gflag);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		11, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_ListEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id;
	struct prcheckentry entry;




	if ((!xdr_afs_int32(z_xdrs, &id))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_ListEntry(z_call, id, &entry);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prcheckentry(z_xdrs, &entry)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		12, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_ChangeEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id, oid, newid;
	char * name=(char *)0;



	if ((!xdr_afs_int32(z_xdrs, &id))
	     || (!xdr_string(z_xdrs, &name, PR_MAXNAMELEN))
	     || (!xdr_afs_int32(z_xdrs, &oid))
	     || (!xdr_afs_int32(z_xdrs, &newid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_ChangeEntry(z_call, id, name, oid, newid);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, PR_MAXNAMELEN)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		13, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		13, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_ListElements(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id;
	prlist elist;
	afs_int32 over;



	elist.prlist_val = 0;
	elist.prlist_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &id))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_ListElements(z_call, id, &elist, &over);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prlist(z_xdrs, &elist))
	     || (!xdr_afs_int32(z_xdrs, &over)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_prlist(z_xdrs, &elist)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		14, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		14, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_IsAMemberOf(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 uid, gid;
	afs_int32 flag;




	if ((!xdr_afs_int32(z_xdrs, &uid))
	     || (!xdr_afs_int32(z_xdrs, &gid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_IsAMemberOf(z_call, uid, gid, &flag);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &flag)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		15, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_SetFieldsEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id, mask, flags, ngroups, nusers, spare1, spare2;




	if ((!xdr_afs_int32(z_xdrs, &id))
	     || (!xdr_afs_int32(z_xdrs, &mask))
	     || (!xdr_afs_int32(z_xdrs, &flags))
	     || (!xdr_afs_int32(z_xdrs, &ngroups))
	     || (!xdr_afs_int32(z_xdrs, &nusers))
	     || (!xdr_afs_int32(z_xdrs, &spare1))
	     || (!xdr_afs_int32(z_xdrs, &spare2))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_SetFieldsEntry(z_call, id, mask, flags, ngroups, nusers, spare1, spare2);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		16, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _PR_ListOwned(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id;
	prlist elist;
	afs_int32 lastp;



	elist.prlist_val = 0;
	elist.prlist_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &id))
	     || (!xdr_afs_int32(z_xdrs, &lastp))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_ListOwned(z_call, id, &elist, &lastp);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prlist(z_xdrs, &elist))
	     || (!xdr_afs_int32(z_xdrs, &lastp)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_prlist(z_xdrs, &elist)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		17, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		17, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_GetCPS2(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id, host;
	prlist elist;
	afs_int32 over;



	elist.prlist_val = 0;
	elist.prlist_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &id))
	     || (!xdr_afs_int32(z_xdrs, &host))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_GetCPS2(z_call, id, host, &elist, &over);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prlist(z_xdrs, &elist))
	     || (!xdr_afs_int32(z_xdrs, &over)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_prlist(z_xdrs, &elist)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		18, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		18, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_GetHostCPS(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 host;
	prlist elist;
	afs_int32 over;



	elist.prlist_val = 0;
	elist.prlist_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &host))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_GetHostCPS(z_call, host, &elist, &over);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prlist(z_xdrs, &elist))
	     || (!xdr_afs_int32(z_xdrs, &over)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_prlist(z_xdrs, &elist)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		19, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		19, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_UpdateEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id;
	char * name=(char *)0;
	PrUpdateEntry uentry;



	if ((!xdr_afs_int32(z_xdrs, &id))
	     || (!xdr_string(z_xdrs, &name, PR_MAXNAMELEN))
	     || (!xdr_PrUpdateEntry(z_xdrs, &uentry))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_UpdateEntry(z_call, id, name, &uentry);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, PR_MAXNAMELEN)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		20, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		20, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_ListEntries(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 flags, startindex;
	prentries bulkentries;
	afs_int32 nextstartindex;



	bulkentries.prentries_val = 0;
	bulkentries.prentries_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &flags))
	     || (!xdr_afs_int32(z_xdrs, &startindex))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_ListEntries(z_call, flags, startindex, &bulkentries, &nextstartindex);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prentries(z_xdrs, &bulkentries))
	     || (!xdr_afs_int32(z_xdrs, &nextstartindex)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_prentries(z_xdrs, &bulkentries)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		21, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		21, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _PR_ListSuperGroups(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 id;
	prlist elist;
	afs_int32 over;



	elist.prlist_val = 0;
	elist.prlist_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &id))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SPR_ListSuperGroups(z_call, id, &elist, &over);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_prlist(z_xdrs, &elist))
	     || (!xdr_afs_int32(z_xdrs, &over)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_prlist(z_xdrs, &elist)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		22, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, PR_STATINDEX,
		22, PR_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}


int PR_ExecuteRequest (register struct rx_call *z_call)
{
	int op;
	XDR z_xdrs;
	afs_int32 z_result;

	xdrrx_create(&z_xdrs, z_call, XDR_DECODE);
	z_result = RXGEN_DECODE;
	if (!xdr_int(&z_xdrs, &op)) goto fail;
	switch (op) {
		case 500:
			z_result = _PR_INewEntry(z_call, &z_xdrs);
			break;
		case 501:
			z_result = _PR_WhereIsIt(z_call, &z_xdrs);
			break;
		case 502:
			z_result = _PR_DumpEntry(z_call, &z_xdrs);
			break;
		case 503:
			z_result = _PR_AddToGroup(z_call, &z_xdrs);
			break;
		case 504:
			z_result = _PR_NameToID(z_call, &z_xdrs);
			break;
		case 505:
			z_result = _PR_IDToName(z_call, &z_xdrs);
			break;
		case 506:
			z_result = _PR_Delete(z_call, &z_xdrs);
			break;
		case 507:
			z_result = _PR_RemoveFromGroup(z_call, &z_xdrs);
			break;
		case 508:
			z_result = _PR_GetCPS(z_call, &z_xdrs);
			break;
		case 509:
			z_result = _PR_NewEntry(z_call, &z_xdrs);
			break;
		case 510:
			z_result = _PR_ListMax(z_call, &z_xdrs);
			break;
		case 511:
			z_result = _PR_SetMax(z_call, &z_xdrs);
			break;
		case 512:
			z_result = _PR_ListEntry(z_call, &z_xdrs);
			break;
		case 513:
			z_result = _PR_ChangeEntry(z_call, &z_xdrs);
			break;
		case 514:
			z_result = _PR_ListElements(z_call, &z_xdrs);
			break;
		case 515:
			z_result = _PR_IsAMemberOf(z_call, &z_xdrs);
			break;
		case 516:
			z_result = _PR_SetFieldsEntry(z_call, &z_xdrs);
			break;
		case 517:
			z_result = _PR_ListOwned(z_call, &z_xdrs);
			break;
		case 518:
			z_result = _PR_GetCPS2(z_call, &z_xdrs);
			break;
		case 519:
			z_result = _PR_GetHostCPS(z_call, &z_xdrs);
			break;
		case 520:
			z_result = _PR_UpdateEntry(z_call, &z_xdrs);
			break;
		case 521:
			z_result = _PR_ListEntries(z_call, &z_xdrs);
			break;
		case 530:
			z_result = _PR_ListSuperGroups(z_call, &z_xdrs);
			break;
		default:
			z_result = RXGEN_OPCODE;
			break;
	}
fail:
	return z_result;
}