/* dcerpc client calls generated by pidl */

#include "includes.h"


NTSTATUS dcerpc_spoolss_EnumPrinters(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_EnumPrinters *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_EnumPrinters, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_ENUMPRINTERS, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_EnumPrinters,
				    (ndr_pull_fn_t) ndr_pull_spoolss_EnumPrinters,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinters, r);		
	}

	return status;
}

NTSTATUS dcerpc_spoolss_OpenPrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_OpenPrinter *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_OpenPrinter, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_OPENPRINTER, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_OpenPrinter,
				    (ndr_pull_fn_t) ndr_pull_spoolss_OpenPrinter,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinter, r);		
	}

	return status;
}

NTSTATUS dcerpc_spoolss_02(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_02 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_02, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_02, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_02,
				    (ndr_pull_fn_t) ndr_pull_spoolss_02,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_02, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_03(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_03 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_03, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_03, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_03,
				    (ndr_pull_fn_t) ndr_pull_spoolss_03,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_03, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_EnumJobs(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_EnumJobs *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_EnumJobs, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_ENUMJOBS, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_EnumJobs,
				    (ndr_pull_fn_t) ndr_pull_spoolss_EnumJobs,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_05(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_05 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_05, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_05, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_05,
				    (ndr_pull_fn_t) ndr_pull_spoolss_05,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_05, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_06(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_06 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_06, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_06, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_06,
				    (ndr_pull_fn_t) ndr_pull_spoolss_06,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_06, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_07(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_07 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_07, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_07, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_07,
				    (ndr_pull_fn_t) ndr_pull_spoolss_07,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_07, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_GetPrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_GetPrinter *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_GetPrinter, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_GETPRINTER, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_GetPrinter,
				    (ndr_pull_fn_t) ndr_pull_spoolss_GetPrinter,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_GetPrinter, r);		
	}

	return status;
}

NTSTATUS dcerpc_spoolss_09(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_09 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_09, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_09, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_09,
				    (ndr_pull_fn_t) ndr_pull_spoolss_09,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_09, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_0a(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_0a *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_0a, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_0A, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_0a,
				    (ndr_pull_fn_t) ndr_pull_spoolss_0a,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_0a, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_0b(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_0b *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_0b, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_0B, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_0b,
				    (ndr_pull_fn_t) ndr_pull_spoolss_0b,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_0b, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_0c(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_0c *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_0c, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_0C, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_0c,
				    (ndr_pull_fn_t) ndr_pull_spoolss_0c,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_0c, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_0d(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_0d *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_0d, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_0D, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_0d,
				    (ndr_pull_fn_t) ndr_pull_spoolss_0d,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_0d, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_0e(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_0e *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_0e, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_0E, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_0e,
				    (ndr_pull_fn_t) ndr_pull_spoolss_0e,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_0e, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_0f(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_0f *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_0f, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_0F, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_0f,
				    (ndr_pull_fn_t) ndr_pull_spoolss_0f,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_0f, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_10(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_10 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_10, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_10, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_10,
				    (ndr_pull_fn_t) ndr_pull_spoolss_10,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_10, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_11(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_11 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_11, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_11, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_11,
				    (ndr_pull_fn_t) ndr_pull_spoolss_11,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_11, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_StartPagePrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_StartPagePrinter *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_StartPagePrinter, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_STARTPAGEPRINTER, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_StartPagePrinter,
				    (ndr_pull_fn_t) ndr_pull_spoolss_StartPagePrinter,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_StartPagePrinter, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_13(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_13 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_13, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_13, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_13,
				    (ndr_pull_fn_t) ndr_pull_spoolss_13,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_13, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_EndPagePrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_EndPagePrinter *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_EndPagePrinter, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_ENDPAGEPRINTER, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_EndPagePrinter,
				    (ndr_pull_fn_t) ndr_pull_spoolss_EndPagePrinter,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_EndPagePrinter, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_15(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_15 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_15, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_15, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_15,
				    (ndr_pull_fn_t) ndr_pull_spoolss_15,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_15, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_16(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_16 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_16, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_16, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_16,
				    (ndr_pull_fn_t) ndr_pull_spoolss_16,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_16, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_EndDocPrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_EndDocPrinter *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_EndDocPrinter, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_ENDDOCPRINTER, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_EndDocPrinter,
				    (ndr_pull_fn_t) ndr_pull_spoolss_EndDocPrinter,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_EndDocPrinter, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_18(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_18 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_18, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_18, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_18,
				    (ndr_pull_fn_t) ndr_pull_spoolss_18,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_18, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_19(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_19 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_19, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_19, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_19,
				    (ndr_pull_fn_t) ndr_pull_spoolss_19,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_19, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_1a(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_1a *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_1a, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_1A, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_1a,
				    (ndr_pull_fn_t) ndr_pull_spoolss_1a,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_1a, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_1b(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_1b *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_1b, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_1B, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_1b,
				    (ndr_pull_fn_t) ndr_pull_spoolss_1b,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_1b, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_1c(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_1c *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_1c, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_1C, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_1c,
				    (ndr_pull_fn_t) ndr_pull_spoolss_1c,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_1c, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_ClosePrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_ClosePrinter *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_ClosePrinter, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_CLOSEPRINTER, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_ClosePrinter,
				    (ndr_pull_fn_t) ndr_pull_spoolss_ClosePrinter,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_ClosePrinter, r);		
	}

	return status;
}

NTSTATUS dcerpc_spoolss_1e(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_1e *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_1e, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_1E, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_1e,
				    (ndr_pull_fn_t) ndr_pull_spoolss_1e,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_1e, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_1f(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_1f *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_1f, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_1F, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_1f,
				    (ndr_pull_fn_t) ndr_pull_spoolss_1f,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_1f, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_20(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_20 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_20, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_20, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_20,
				    (ndr_pull_fn_t) ndr_pull_spoolss_20,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_20, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_21(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_21 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_21, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_21, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_21,
				    (ndr_pull_fn_t) ndr_pull_spoolss_21,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_21, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_22(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_22 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_22, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_22, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_22,
				    (ndr_pull_fn_t) ndr_pull_spoolss_22,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_22, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_23(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_23 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_23, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_23, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_23,
				    (ndr_pull_fn_t) ndr_pull_spoolss_23,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_23, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_24(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_24 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_24, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_24, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_24,
				    (ndr_pull_fn_t) ndr_pull_spoolss_24,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_24, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_25(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_25 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_25, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_25, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_25,
				    (ndr_pull_fn_t) ndr_pull_spoolss_25,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_25, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_26(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_26 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_26, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_26, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_26,
				    (ndr_pull_fn_t) ndr_pull_spoolss_26,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_26, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_27(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_27 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_27, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_27, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_27,
				    (ndr_pull_fn_t) ndr_pull_spoolss_27,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_27, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_28(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_28 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_28, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_28, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_28,
				    (ndr_pull_fn_t) ndr_pull_spoolss_28,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_28, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_29(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_29 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_29, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_29, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_29,
				    (ndr_pull_fn_t) ndr_pull_spoolss_29,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_29, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_2a(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_2a *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_2a, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_2A, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_2a,
				    (ndr_pull_fn_t) ndr_pull_spoolss_2a,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_2a, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_2b(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_2b *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_2b, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_2B, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_2b,
				    (ndr_pull_fn_t) ndr_pull_spoolss_2b,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_2b, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_2c(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_2c *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_2c, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_2C, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_2c,
				    (ndr_pull_fn_t) ndr_pull_spoolss_2c,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_2c, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_2d(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_2d *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_2d, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_2D, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_2d,
				    (ndr_pull_fn_t) ndr_pull_spoolss_2d,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_2d, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_2e(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_2e *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_2e, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_2E, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_2e,
				    (ndr_pull_fn_t) ndr_pull_spoolss_2e,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_2e, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_2f(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_2f *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_2f, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_2F, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_2f,
				    (ndr_pull_fn_t) ndr_pull_spoolss_2f,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_2f, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_30(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_30 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_30, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_30, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_30,
				    (ndr_pull_fn_t) ndr_pull_spoolss_30,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_30, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_31(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_31 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_31, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_31, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_31,
				    (ndr_pull_fn_t) ndr_pull_spoolss_31,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_31, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_32(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_32 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_32, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_32, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_32,
				    (ndr_pull_fn_t) ndr_pull_spoolss_32,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_32, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_33(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_33 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_33, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_33, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_33,
				    (ndr_pull_fn_t) ndr_pull_spoolss_33,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_33, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_34(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_34 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_34, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_34, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_34,
				    (ndr_pull_fn_t) ndr_pull_spoolss_34,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_34, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_35(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_35 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_35, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_35, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_35,
				    (ndr_pull_fn_t) ndr_pull_spoolss_35,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_35, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_36(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_36 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_36, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_36, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_36,
				    (ndr_pull_fn_t) ndr_pull_spoolss_36,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_36, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_37(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_37 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_37, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_37, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_37,
				    (ndr_pull_fn_t) ndr_pull_spoolss_37,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_37, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_38(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_38 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_38, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_38, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_38,
				    (ndr_pull_fn_t) ndr_pull_spoolss_38,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_38, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_39(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_39 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_39, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_39, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_39,
				    (ndr_pull_fn_t) ndr_pull_spoolss_39,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_39, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_3a(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_3a *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_3a, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_3A, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_3a,
				    (ndr_pull_fn_t) ndr_pull_spoolss_3a,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_3a, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_3b(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_3b *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_3b, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_3B, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_3b,
				    (ndr_pull_fn_t) ndr_pull_spoolss_3b,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_3b, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_3c(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_3c *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_3c, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_3C, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_3c,
				    (ndr_pull_fn_t) ndr_pull_spoolss_3c,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_3c, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_3d(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_3d *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_3d, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_3D, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_3d,
				    (ndr_pull_fn_t) ndr_pull_spoolss_3d,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_3d, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_3e(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_3e *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_3e, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_3E, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_3e,
				    (ndr_pull_fn_t) ndr_pull_spoolss_3e,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_3e, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_3f(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_3f *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_3f, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_3F, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_3f,
				    (ndr_pull_fn_t) ndr_pull_spoolss_3f,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_3f, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_40(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_40 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_40, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_40, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_40,
				    (ndr_pull_fn_t) ndr_pull_spoolss_40,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_40, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_41(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_41 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_41, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_41, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_41,
				    (ndr_pull_fn_t) ndr_pull_spoolss_41,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_41, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_42(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_42 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_42, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_42, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_42,
				    (ndr_pull_fn_t) ndr_pull_spoolss_42,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_42, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_43(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_43 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_43, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_43, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_43,
				    (ndr_pull_fn_t) ndr_pull_spoolss_43,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_43, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_44(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_44 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_44, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_44, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_44,
				    (ndr_pull_fn_t) ndr_pull_spoolss_44,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_44, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_OpenPrinterEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_OpenPrinterEx *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_OpenPrinterEx, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_OPENPRINTEREX, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_OpenPrinterEx,
				    (ndr_pull_fn_t) ndr_pull_spoolss_OpenPrinterEx,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinterEx, r);		
	}

	return status;
}

NTSTATUS dcerpc_spoolss_46(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_46 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_46, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_46, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_46,
				    (ndr_pull_fn_t) ndr_pull_spoolss_46,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_46, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_47(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_47 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_47, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_47, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_47,
				    (ndr_pull_fn_t) ndr_pull_spoolss_47,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_47, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_EnumPrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_EnumPrinterData *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterData, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_ENUMPRINTERDATA, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_EnumPrinterData,
				    (ndr_pull_fn_t) ndr_pull_spoolss_EnumPrinterData,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterData, r);		
	}

	return status;
}

NTSTATUS dcerpc_spoolss_49(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_49 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_49, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_49, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_49,
				    (ndr_pull_fn_t) ndr_pull_spoolss_49,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_49, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_4a(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_4a *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_4a, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_4A, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_4a,
				    (ndr_pull_fn_t) ndr_pull_spoolss_4a,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_4a, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_4b(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_4b *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_4b, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_4B, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_4b,
				    (ndr_pull_fn_t) ndr_pull_spoolss_4b,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_4b, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_4c(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_4c *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_4c, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_4C, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_4c,
				    (ndr_pull_fn_t) ndr_pull_spoolss_4c,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_4c, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_4d(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_4d *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_4d, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_4D, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_4d,
				    (ndr_pull_fn_t) ndr_pull_spoolss_4d,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_4d, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_4e(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_4e *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_4e, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_4E, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_4e,
				    (ndr_pull_fn_t) ndr_pull_spoolss_4e,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_4e, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_4f(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_4f *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_4f, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_4F, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_4f,
				    (ndr_pull_fn_t) ndr_pull_spoolss_4f,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_4f, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_50(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_50 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_50, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_50, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_50,
				    (ndr_pull_fn_t) ndr_pull_spoolss_50,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_50, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_51(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_51 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_51, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_51, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_51,
				    (ndr_pull_fn_t) ndr_pull_spoolss_51,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_51, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_52(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_52 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_52, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_52, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_52,
				    (ndr_pull_fn_t) ndr_pull_spoolss_52,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_52, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_53(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_53 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_53, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_53, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_53,
				    (ndr_pull_fn_t) ndr_pull_spoolss_53,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_53, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_54(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_54 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_54, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_54, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_54,
				    (ndr_pull_fn_t) ndr_pull_spoolss_54,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_54, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_55(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_55 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_55, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_55, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_55,
				    (ndr_pull_fn_t) ndr_pull_spoolss_55,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_55, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_56(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_56 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_56, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_56, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_56,
				    (ndr_pull_fn_t) ndr_pull_spoolss_56,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_56, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_57(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_57 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_57, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_57, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_57,
				    (ndr_pull_fn_t) ndr_pull_spoolss_57,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_57, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_58(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_58 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_58, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_58, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_58,
				    (ndr_pull_fn_t) ndr_pull_spoolss_58,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_58, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_59(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_59 *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_59, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_59, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_59,
				    (ndr_pull_fn_t) ndr_pull_spoolss_59,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_59, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_5a(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_5a *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_5a, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_5A, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_5a,
				    (ndr_pull_fn_t) ndr_pull_spoolss_5a,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_5a, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_5b(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_5b *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_5b, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_5B, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_5b,
				    (ndr_pull_fn_t) ndr_pull_spoolss_5b,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_5b, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_5c(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_5c *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_5c, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_5C, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_5c,
				    (ndr_pull_fn_t) ndr_pull_spoolss_5c,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_5c, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_5d(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_5d *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_5d, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_5D, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_5d,
				    (ndr_pull_fn_t) ndr_pull_spoolss_5d,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_5d, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_5e(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_5e *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_5e, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_5E, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_5e,
				    (ndr_pull_fn_t) ndr_pull_spoolss_5e,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_5e, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}

NTSTATUS dcerpc_spoolss_5f(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct spoolss_5f *r)
{
	NTSTATUS status;

        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
		NDR_PRINT_IN_DEBUG(spoolss_5f, r);		
	}

	status = dcerpc_ndr_request(p, DCERPC_SPOOLSS_5F, mem_ctx,
				    (ndr_push_fn_t) ndr_push_spoolss_5f,
				    (ndr_pull_fn_t) ndr_pull_spoolss_5f,
				    r);

        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
		NDR_PRINT_OUT_DEBUG(spoolss_5f, r);		
	}
	if (NT_STATUS_IS_OK(status)) status = r->out.result;

	return status;
}