* use the new auto-generated debug code method.

* add a couple more info levels to wkssvc
(This used to be commit c69161bdb13745f271b0cfa9a9af349f7a95edc6)

8 files changed, 2521 insertions, 899 deletions

diff --git a/source4/librpc/rpc/dcerpc.h b/source4/librpc/rpc/dcerpc.h
index 09ddc3625c..d67969e76c 100644
--- a/source4/librpc/rpc/dcerpc.h
+++ b/source4/librpc/rpc/dcerpc.h
@@ -37,6 +37,7 @@ struct dcerpc_pipe {
 	uint32 srv_max_xmit_frag;
 	uint32 srv_max_recv_frag;
 	struct cli_tree *tree;
+	unsigned flags;
 };
 
 /* dcerpc packet types */
@@ -51,6 +52,11 @@ struct dcerpc_pipe {
 #define DCERPC_PFC_FLAG_LAST    0x02
 #define DCERPC_PFC_FLAG_NOCALL  0x20
 
+/* dcerpc pipe flags */
+#define DCERPC_DEBUG_PRINT_IN 1
+#define DCERPC_DEBUG_PRINT_OUT 2
+#define DCERPC_DEBUG_PRINT_BOTH (DCERPC_DEBUG_PRINT_IN | DCERPC_DEBUG_PRINT_OUT)
+
 /*
   all dcerpc packets use this structure. 
 */
diff --git a/source4/librpc/rpc/rpc_dfs.c b/source4/librpc/rpc/rpc_dfs.c
index e4501676dd..4de98ad5f6 100644
--- a/source4/librpc/rpc/rpc_dfs.c
+++ b/source4/librpc/rpc/rpc_dfs.c
@@ -1,82 +1,129 @@
-/* dcerpc client calls auto-generated by pidl */
+/* dcerpc client calls generated by pidl */
 
 #include "includes.h"
 
 
 NTSTATUS dcerpc_dfs_Exist(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct dfs_Exist *r)
 {
-	return dcerpc_ndr_request(p, DCERPC_DFS_EXIST, mem_ctx,
-				  (ndr_push_fn_t) ndr_push_dfs_Exist,
-				  (ndr_pull_fn_t) ndr_pull_dfs_Exist,
-				  r);
+	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(dfs_Exist, r);		
+	}
+
+	status = dcerpc_ndr_request(p, DCERPC_DFS_EXIST, mem_ctx,
+				    (ndr_push_fn_t) ndr_push_dfs_Exist,
+				    (ndr_pull_fn_t) ndr_pull_dfs_Exist,
+				    r);
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(dfs_Exist, r);		
+	}
+
+	return status;
 }
 
 NTSTATUS dcerpc_dfs_Add(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct dfs_Add *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(dfs_Add, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_DFS_ADD, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_dfs_Add,
 				    (ndr_pull_fn_t) ndr_pull_dfs_Add,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(dfs_Add, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_dfs_Remove(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct dfs_Remove *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(dfs_Remove, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_DFS_REMOVE, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_dfs_Remove,
 				    (ndr_pull_fn_t) ndr_pull_dfs_Remove,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(dfs_Remove, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_dfs_SetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct dfs_SetInfo *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(dfs_SetInfo, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_DFS_SETINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_dfs_SetInfo,
 				    (ndr_pull_fn_t) ndr_pull_dfs_SetInfo,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(dfs_SetInfo, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_dfs_GetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct dfs_GetInfo *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(dfs_GetInfo, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_DFS_GETINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_dfs_GetInfo,
 				    (ndr_pull_fn_t) ndr_pull_dfs_GetInfo,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(dfs_GetInfo, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_dfs_Enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct dfs_Enum *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(dfs_Enum, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_DFS_ENUM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_dfs_Enum,
 				    (ndr_pull_fn_t) ndr_pull_dfs_Enum,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(dfs_Enum, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
diff --git a/source4/librpc/rpc/rpc_echo.c b/source4/librpc/rpc/rpc_echo.c
index b7e3bf4e7c..38b394dbf6 100644
--- a/source4/librpc/rpc/rpc_echo.c
+++ b/source4/librpc/rpc/rpc_echo.c
@@ -1,44 +1,104 @@
-/* dcerpc client calls auto-generated by pidl */
+/* dcerpc client calls generated by pidl */
 
 #include "includes.h"
 
 
 NTSTATUS dcerpc_echo_AddOne(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct echo_AddOne *r)
 {
-	return dcerpc_ndr_request(p, DCERPC_ECHO_ADDONE, mem_ctx,
-				  (ndr_push_fn_t) ndr_push_echo_AddOne,
-				  (ndr_pull_fn_t) ndr_pull_echo_AddOne,
-				  r);
+	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(echo_AddOne, r);		
+	}
+
+	status = dcerpc_ndr_request(p, DCERPC_ECHO_ADDONE, mem_ctx,
+				    (ndr_push_fn_t) ndr_push_echo_AddOne,
+				    (ndr_pull_fn_t) ndr_pull_echo_AddOne,
+				    r);
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(echo_AddOne, r);		
+	}
+
+	return status;
 }
 
 NTSTATUS dcerpc_echo_EchoData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct echo_EchoData *r)
 {
-	return dcerpc_ndr_request(p, DCERPC_ECHO_ECHODATA, mem_ctx,
-				  (ndr_push_fn_t) ndr_push_echo_EchoData,
-				  (ndr_pull_fn_t) ndr_pull_echo_EchoData,
-				  r);
+	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(echo_EchoData, r);		
+	}
+
+	status = dcerpc_ndr_request(p, DCERPC_ECHO_ECHODATA, mem_ctx,
+				    (ndr_push_fn_t) ndr_push_echo_EchoData,
+				    (ndr_pull_fn_t) ndr_pull_echo_EchoData,
+				    r);
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(echo_EchoData, r);		
+	}
+
+	return status;
 }
 
 NTSTATUS dcerpc_echo_SinkData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct echo_SinkData *r)
 {
-	return dcerpc_ndr_request(p, DCERPC_ECHO_SINKDATA, mem_ctx,
-				  (ndr_push_fn_t) ndr_push_echo_SinkData,
-				  (ndr_pull_fn_t) ndr_pull_echo_SinkData,
-				  r);
+	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(echo_SinkData, r);		
+	}
+
+	status = dcerpc_ndr_request(p, DCERPC_ECHO_SINKDATA, mem_ctx,
+				    (ndr_push_fn_t) ndr_push_echo_SinkData,
+				    (ndr_pull_fn_t) ndr_pull_echo_SinkData,
+				    r);
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(echo_SinkData, r);		
+	}
+
+	return status;
 }
 
 NTSTATUS dcerpc_echo_SourceData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct echo_SourceData *r)
 {
-	return dcerpc_ndr_request(p, DCERPC_ECHO_SOURCEDATA, mem_ctx,
-				  (ndr_push_fn_t) ndr_push_echo_SourceData,
-				  (ndr_pull_fn_t) ndr_pull_echo_SourceData,
-				  r);
+	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(echo_SourceData, r);		
+	}
+
+	status = dcerpc_ndr_request(p, DCERPC_ECHO_SOURCEDATA, mem_ctx,
+				    (ndr_push_fn_t) ndr_push_echo_SourceData,
+				    (ndr_pull_fn_t) ndr_pull_echo_SourceData,
+				    r);
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(echo_SourceData, r);		
+	}
+
+	return status;
 }
 
 NTSTATUS dcerpc_TestCall(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct TestCall *r)
 {
-	return dcerpc_ndr_request(p, DCERPC_TESTCALL, mem_ctx,
-				  (ndr_push_fn_t) ndr_push_TestCall,
-				  (ndr_pull_fn_t) ndr_pull_TestCall,
-				  r);
+	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(TestCall, r);		
+	}
+
+	status = dcerpc_ndr_request(p, DCERPC_TESTCALL, mem_ctx,
+				    (ndr_push_fn_t) ndr_push_TestCall,
+				    (ndr_pull_fn_t) ndr_pull_TestCall,
+				    r);
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(TestCall, r);		
+	}
+
+	return status;
 }
diff --git a/source4/librpc/rpc/rpc_lsa.c b/source4/librpc/rpc/rpc_lsa.c
index 1b5886b90f..c6e956abaf 100644
--- a/source4/librpc/rpc/rpc_lsa.c
+++ b/source4/librpc/rpc/rpc_lsa.c
@@ -1,4 +1,4 @@
-/* dcerpc client calls auto-generated by pidl */
+/* dcerpc client calls generated by pidl */
 
 #include "includes.h"
 
@@ -6,657 +6,986 @@
 NTSTATUS dcerpc_lsa_Close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_Close *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_Close, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_CLOSE, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_Close,
 				    (ndr_pull_fn_t) ndr_pull_lsa_Close,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_Close, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_Delete(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_Delete *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_Delete, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_DELETE, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_Delete,
 				    (ndr_pull_fn_t) ndr_pull_lsa_Delete,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_Delete, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_EnumPrivs(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_EnumPrivs *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_EnumPrivs, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_ENUMPRIVS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_EnumPrivs,
 				    (ndr_pull_fn_t) ndr_pull_lsa_EnumPrivs,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_QuerySecObj(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_QuerySecObj *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_QuerySecObj, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_QUERYSECOBJ, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_QuerySecObj,
 				    (ndr_pull_fn_t) ndr_pull_lsa_QuerySecObj,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_QuerySecObj, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_SetSecObj(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_SetSecObj *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_SetSecObj, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_SETSECOBJ, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_SetSecObj,
 				    (ndr_pull_fn_t) ndr_pull_lsa_SetSecObj,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_SetSecObj, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_ChangePassword(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_ChangePassword *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_ChangePassword, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_CHANGEPASSWORD, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_ChangePassword,
 				    (ndr_pull_fn_t) ndr_pull_lsa_ChangePassword,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_ChangePassword, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_OpenPolicy(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_OpenPolicy *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_OpenPolicy, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_OPENPOLICY, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_OpenPolicy,
 				    (ndr_pull_fn_t) ndr_pull_lsa_OpenPolicy,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_QueryInfoPolicy(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_QueryInfoPolicy *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_QUERYINFOPOLICY, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_QueryInfoPolicy,
 				    (ndr_pull_fn_t) ndr_pull_lsa_QueryInfoPolicy,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_SetInfoPolicy(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_SetInfoPolicy *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_SETINFOPOLICY, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_SetInfoPolicy,
 				    (ndr_pull_fn_t) ndr_pull_lsa_SetInfoPolicy,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_ClearAuditLog(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_ClearAuditLog *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_CLEARAUDITLOG, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_ClearAuditLog,
 				    (ndr_pull_fn_t) ndr_pull_lsa_ClearAuditLog,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_CreateAccount(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_CreateAccount *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_CreateAccount, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_CREATEACCOUNT, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_CreateAccount,
 				    (ndr_pull_fn_t) ndr_pull_lsa_CreateAccount,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_CreateAccount, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_EnumAccounts(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_EnumAccounts *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_EnumAccounts, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_ENUMACCOUNTS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_EnumAccounts,
 				    (ndr_pull_fn_t) ndr_pull_lsa_EnumAccounts,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_CreateTrustDom(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_CreateTrustDom *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_CreateTrustDom, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_CREATETRUSTDOM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_CreateTrustDom,
 				    (ndr_pull_fn_t) ndr_pull_lsa_CreateTrustDom,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_CreateTrustDom, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_EnumTrustDom(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_EnumTrustDom *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_ENUMTRUSTDOM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_EnumTrustDom,
 				    (ndr_pull_fn_t) ndr_pull_lsa_EnumTrustDom,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_LookupNames(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_LookupNames *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_LookupNames, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_LOOKUPNAMES, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_LookupNames,
 				    (ndr_pull_fn_t) ndr_pull_lsa_LookupNames,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_LookupNames, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_LookupSids(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_LookupSids *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_LookupSids, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_LOOKUPSIDS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_LookupSids,
 				    (ndr_pull_fn_t) ndr_pull_lsa_LookupSids,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_LookupSids, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_CREATESECRET(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct CREATESECRET *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(CREATESECRET, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_CREATESECRET, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_CREATESECRET,
 				    (ndr_pull_fn_t) ndr_pull_CREATESECRET,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(CREATESECRET, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_OpenAccount(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_OpenAccount *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_OpenAccount, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_OPENACCOUNT, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_OpenAccount,
 				    (ndr_pull_fn_t) ndr_pull_lsa_OpenAccount,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_OpenAccount, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_EnumPrivsAccount(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_EnumPrivsAccount *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_ENUMPRIVSACCOUNT, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_EnumPrivsAccount,
 				    (ndr_pull_fn_t) ndr_pull_lsa_EnumPrivsAccount,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_ADDPRIVS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct ADDPRIVS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(ADDPRIVS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_ADDPRIVS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_ADDPRIVS,
 				    (ndr_pull_fn_t) ndr_pull_ADDPRIVS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(ADDPRIVS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_REMOVEPRIVS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct REMOVEPRIVS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(REMOVEPRIVS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_REMOVEPRIVS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_REMOVEPRIVS,
 				    (ndr_pull_fn_t) ndr_pull_REMOVEPRIVS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(REMOVEPRIVS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_GETQUOTAS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct GETQUOTAS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(GETQUOTAS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_GETQUOTAS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_GETQUOTAS,
 				    (ndr_pull_fn_t) ndr_pull_GETQUOTAS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(GETQUOTAS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_SETQUOTAS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct SETQUOTAS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(SETQUOTAS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SETQUOTAS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_SETQUOTAS,
 				    (ndr_pull_fn_t) ndr_pull_SETQUOTAS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(SETQUOTAS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_GETSYSTEMACCOUNT(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct GETSYSTEMACCOUNT *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(GETSYSTEMACCOUNT, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_GETSYSTEMACCOUNT, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_GETSYSTEMACCOUNT,
 				    (ndr_pull_fn_t) ndr_pull_GETSYSTEMACCOUNT,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(GETSYSTEMACCOUNT, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_SETSYSTEMACCOUNT(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct SETSYSTEMACCOUNT *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(SETSYSTEMACCOUNT, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SETSYSTEMACCOUNT, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_SETSYSTEMACCOUNT,
 				    (ndr_pull_fn_t) ndr_pull_SETSYSTEMACCOUNT,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(SETSYSTEMACCOUNT, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_OPENTRUSTDOM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct OPENTRUSTDOM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(OPENTRUSTDOM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_OPENTRUSTDOM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_OPENTRUSTDOM,
 				    (ndr_pull_fn_t) ndr_pull_OPENTRUSTDOM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(OPENTRUSTDOM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_QUERYTRUSTDOM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct QUERYTRUSTDOM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(QUERYTRUSTDOM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_QUERYTRUSTDOM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_QUERYTRUSTDOM,
 				    (ndr_pull_fn_t) ndr_pull_QUERYTRUSTDOM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(QUERYTRUSTDOM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_SETINFOTRUSTDOM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct SETINFOTRUSTDOM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(SETINFOTRUSTDOM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SETINFOTRUSTDOM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_SETINFOTRUSTDOM,
 				    (ndr_pull_fn_t) ndr_pull_SETINFOTRUSTDOM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(SETINFOTRUSTDOM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_OPENSECRET(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct OPENSECRET *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(OPENSECRET, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_OPENSECRET, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_OPENSECRET,
 				    (ndr_pull_fn_t) ndr_pull_OPENSECRET,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(OPENSECRET, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_SETSECRET(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct SETSECRET *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(SETSECRET, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SETSECRET, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_SETSECRET,
 				    (ndr_pull_fn_t) ndr_pull_SETSECRET,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(SETSECRET, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_QUERYSECRET(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct QUERYSECRET *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(QUERYSECRET, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_QUERYSECRET, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_QUERYSECRET,
 				    (ndr_pull_fn_t) ndr_pull_QUERYSECRET,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(QUERYSECRET, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_LOOKUPPRIVVALUE(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct LOOKUPPRIVVALUE *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(LOOKUPPRIVVALUE, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LOOKUPPRIVVALUE, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_LOOKUPPRIVVALUE,
 				    (ndr_pull_fn_t) ndr_pull_LOOKUPPRIVVALUE,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(LOOKUPPRIVVALUE, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_LookupPrivName(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_LookupPrivName *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_LOOKUPPRIVNAME, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_LookupPrivName,
 				    (ndr_pull_fn_t) ndr_pull_lsa_LookupPrivName,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_PRIV_GET_DISPNAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct PRIV_GET_DISPNAME *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(PRIV_GET_DISPNAME, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_PRIV_GET_DISPNAME, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_PRIV_GET_DISPNAME,
 				    (ndr_pull_fn_t) ndr_pull_PRIV_GET_DISPNAME,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(PRIV_GET_DISPNAME, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_DELETEOBJECT(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct DELETEOBJECT *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(DELETEOBJECT, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_DELETEOBJECT, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_DELETEOBJECT,
 				    (ndr_pull_fn_t) ndr_pull_DELETEOBJECT,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(DELETEOBJECT, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_ENUMACCTWITHRIGHT(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct ENUMACCTWITHRIGHT *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(ENUMACCTWITHRIGHT, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_ENUMACCTWITHRIGHT, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_ENUMACCTWITHRIGHT,
 				    (ndr_pull_fn_t) ndr_pull_ENUMACCTWITHRIGHT,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(ENUMACCTWITHRIGHT, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_EnumAccountRights(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_EnumAccountRights *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_ENUMACCOUNTRIGHTS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_EnumAccountRights,
 				    (ndr_pull_fn_t) ndr_pull_lsa_EnumAccountRights,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_ADDACCTRIGHTS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct ADDACCTRIGHTS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(ADDACCTRIGHTS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_ADDACCTRIGHTS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_ADDACCTRIGHTS,
 				    (ndr_pull_fn_t) ndr_pull_ADDACCTRIGHTS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(ADDACCTRIGHTS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_REMOVEACCTRIGHTS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct REMOVEACCTRIGHTS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(REMOVEACCTRIGHTS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_REMOVEACCTRIGHTS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_REMOVEACCTRIGHTS,
 				    (ndr_pull_fn_t) ndr_pull_REMOVEACCTRIGHTS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(REMOVEACCTRIGHTS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_QUERYTRUSTDOMINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct QUERYTRUSTDOMINFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(QUERYTRUSTDOMINFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_QUERYTRUSTDOMINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_QUERYTRUSTDOMINFO,
 				    (ndr_pull_fn_t) ndr_pull_QUERYTRUSTDOMINFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(QUERYTRUSTDOMINFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_SETTRUSTDOMINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct SETTRUSTDOMINFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(SETTRUSTDOMINFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SETTRUSTDOMINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_SETTRUSTDOMINFO,
 				    (ndr_pull_fn_t) ndr_pull_SETTRUSTDOMINFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(SETTRUSTDOMINFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_DELETETRUSTDOM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct DELETETRUSTDOM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(DELETETRUSTDOM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_DELETETRUSTDOM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_DELETETRUSTDOM,
 				    (ndr_pull_fn_t) ndr_pull_DELETETRUSTDOM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(DELETETRUSTDOM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_STOREPRIVDATA(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct STOREPRIVDATA *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(STOREPRIVDATA, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_STOREPRIVDATA, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_STOREPRIVDATA,
 				    (ndr_pull_fn_t) ndr_pull_STOREPRIVDATA,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(STOREPRIVDATA, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_RETRPRIVDATA(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct RETRPRIVDATA *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(RETRPRIVDATA, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_RETRPRIVDATA, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_RETRPRIVDATA,
 				    (ndr_pull_fn_t) ndr_pull_RETRPRIVDATA,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(RETRPRIVDATA, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_lsa_OpenPolicy2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct lsa_OpenPolicy2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_LSA_OPENPOLICY2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_lsa_OpenPolicy2,
 				    (ndr_pull_fn_t) ndr_pull_lsa_OpenPolicy2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_UNK_GET_CONNUSER(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct UNK_GET_CONNUSER *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(UNK_GET_CONNUSER, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_UNK_GET_CONNUSER, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_UNK_GET_CONNUSER,
 				    (ndr_pull_fn_t) ndr_pull_UNK_GET_CONNUSER,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(UNK_GET_CONNUSER, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_QUERYINFO2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct QUERYINFO2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(QUERYINFO2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_QUERYINFO2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_QUERYINFO2,
 				    (ndr_pull_fn_t) ndr_pull_QUERYINFO2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(QUERYINFO2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
diff --git a/source4/librpc/rpc/rpc_misc.c b/source4/librpc/rpc/rpc_misc.c
index 50a5186a1f..473a9b0aa1 100644
--- a/source4/librpc/rpc/rpc_misc.c
+++ b/source4/librpc/rpc/rpc_misc.c
@@ -1,4 +1,4 @@
-/* dcerpc client calls auto-generated by pidl */
+/* dcerpc client calls generated by pidl */
 
 #include "includes.h"
 
diff --git a/source4/librpc/rpc/rpc_samr.c b/source4/librpc/rpc/rpc_samr.c
index 6a1ed98fbb..4ae1977c78 100644
--- a/source4/librpc/rpc/rpc_samr.c
+++ b/source4/librpc/rpc/rpc_samr.c
@@ -1,4 +1,4 @@
-/* dcerpc client calls auto-generated by pidl */
+/* dcerpc client calls generated by pidl */
 
 #include "includes.h"
 
@@ -6,951 +6,1427 @@
 NTSTATUS dcerpc_samr_Connect(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_Connect *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_Connect, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CONNECT, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_Connect,
 				    (ndr_pull_fn_t) ndr_pull_samr_Connect,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_Connect, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_Close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_Close *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_Close, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CLOSE, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_Close,
 				    (ndr_pull_fn_t) ndr_pull_samr_Close,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_Close, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SetSecurity(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SetSecurity *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SetSecurity, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SETSECURITY, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SetSecurity,
 				    (ndr_pull_fn_t) ndr_pull_samr_SetSecurity,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SetSecurity, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QuerySecurity(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QuerySecurity *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QuerySecurity, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERYSECURITY, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QuerySecurity,
 				    (ndr_pull_fn_t) ndr_pull_samr_QuerySecurity,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QuerySecurity, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_Shutdown(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_Shutdown *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_Shutdown, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SHUTDOWN, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_Shutdown,
 				    (ndr_pull_fn_t) ndr_pull_samr_Shutdown,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_Shutdown, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_LookupDomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_LookupDomain *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_LookupDomain, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_LOOKUPDOMAIN, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_LookupDomain,
 				    (ndr_pull_fn_t) ndr_pull_samr_LookupDomain,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_LookupDomain, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_EnumDomains(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_EnumDomains *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_EnumDomains, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_ENUMDOMAINS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_EnumDomains,
 				    (ndr_pull_fn_t) ndr_pull_samr_EnumDomains,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_EnumDomains, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_OpenDomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_OpenDomain *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_OpenDomain, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_OPENDOMAIN, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_OpenDomain,
 				    (ndr_pull_fn_t) ndr_pull_samr_OpenDomain,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_OpenDomain, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QueryDomainInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QueryDomainInfo *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERYDOMAININFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QueryDomainInfo,
 				    (ndr_pull_fn_t) ndr_pull_samr_QueryDomainInfo,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SET_DOMAIN_INFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SET_DOMAIN_INFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SET_DOMAIN_INFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SET_DOMAIN_INFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SET_DOMAIN_INFO,
 				    (ndr_pull_fn_t) ndr_pull_samr_SET_DOMAIN_INFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SET_DOMAIN_INFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_CREATE_DOM_GROUP(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CREATE_DOM_GROUP *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_CREATE_DOM_GROUP, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CREATE_DOM_GROUP, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_CREATE_DOM_GROUP,
 				    (ndr_pull_fn_t) ndr_pull_samr_CREATE_DOM_GROUP,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_CREATE_DOM_GROUP, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_EnumDomainGroups(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_EnumDomainGroups *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_EnumDomainGroups, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_ENUMDOMAINGROUPS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_EnumDomainGroups,
 				    (ndr_pull_fn_t) ndr_pull_samr_EnumDomainGroups,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_EnumDomainGroups, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_CREATE_USER_IN_DOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CREATE_USER_IN_DOMAIN *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_CREATE_USER_IN_DOMAIN, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CREATE_USER_IN_DOMAIN, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_CREATE_USER_IN_DOMAIN,
 				    (ndr_pull_fn_t) ndr_pull_samr_CREATE_USER_IN_DOMAIN,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_CREATE_USER_IN_DOMAIN, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_EnumDomainUsers(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_EnumDomainUsers *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_EnumDomainUsers, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_ENUMDOMAINUSERS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_EnumDomainUsers,
 				    (ndr_pull_fn_t) ndr_pull_samr_EnumDomainUsers,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_EnumDomainUsers, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_CREATE_DOM_ALIAS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CREATE_DOM_ALIAS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_CREATE_DOM_ALIAS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CREATE_DOM_ALIAS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_CREATE_DOM_ALIAS,
 				    (ndr_pull_fn_t) ndr_pull_samr_CREATE_DOM_ALIAS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_CREATE_DOM_ALIAS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_EnumDomainAliases(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_EnumDomainAliases *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_EnumDomainAliases, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_ENUMDOMAINALIASES, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_EnumDomainAliases,
 				    (ndr_pull_fn_t) ndr_pull_samr_EnumDomainAliases,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_EnumDomainAliases, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_GET_ALIAS_MEMBERSHIP(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_ALIAS_MEMBERSHIP *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_GET_ALIAS_MEMBERSHIP, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_ALIAS_MEMBERSHIP, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_GET_ALIAS_MEMBERSHIP,
 				    (ndr_pull_fn_t) ndr_pull_samr_GET_ALIAS_MEMBERSHIP,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_GET_ALIAS_MEMBERSHIP, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_LOOKUP_NAMES(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_LOOKUP_NAMES *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_LOOKUP_NAMES, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_LOOKUP_NAMES, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_LOOKUP_NAMES,
 				    (ndr_pull_fn_t) ndr_pull_samr_LOOKUP_NAMES,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_LOOKUP_NAMES, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_LOOKUP_RIDS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_LOOKUP_RIDS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_LOOKUP_RIDS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_LOOKUP_RIDS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_LOOKUP_RIDS,
 				    (ndr_pull_fn_t) ndr_pull_samr_LOOKUP_RIDS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_LOOKUP_RIDS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_OpenGroup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_OpenGroup *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_OpenGroup, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_OPENGROUP, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_OpenGroup,
 				    (ndr_pull_fn_t) ndr_pull_samr_OpenGroup,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_OpenGroup, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QueryGroupInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QueryGroupInfo *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QueryGroupInfo, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERYGROUPINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QueryGroupInfo,
 				    (ndr_pull_fn_t) ndr_pull_samr_QueryGroupInfo,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QueryGroupInfo, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SET_GROUPINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SET_GROUPINFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SET_GROUPINFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SET_GROUPINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SET_GROUPINFO,
 				    (ndr_pull_fn_t) ndr_pull_samr_SET_GROUPINFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SET_GROUPINFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_ADD_GROUPMEM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_ADD_GROUPMEM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_ADD_GROUPMEM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_ADD_GROUPMEM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_ADD_GROUPMEM,
 				    (ndr_pull_fn_t) ndr_pull_samr_ADD_GROUPMEM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_ADD_GROUPMEM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_DELETE_DOM_GROUP(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_DELETE_DOM_GROUP *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_DELETE_DOM_GROUP, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_DELETE_DOM_GROUP, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_DELETE_DOM_GROUP,
 				    (ndr_pull_fn_t) ndr_pull_samr_DELETE_DOM_GROUP,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_DELETE_DOM_GROUP, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_DEL_GROUPMEM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_DEL_GROUPMEM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_DEL_GROUPMEM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_DEL_GROUPMEM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_DEL_GROUPMEM,
 				    (ndr_pull_fn_t) ndr_pull_samr_DEL_GROUPMEM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_DEL_GROUPMEM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QUERY_GROUPMEM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QUERY_GROUPMEM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QUERY_GROUPMEM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERY_GROUPMEM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QUERY_GROUPMEM,
 				    (ndr_pull_fn_t) ndr_pull_samr_QUERY_GROUPMEM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QUERY_GROUPMEM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SET_MEMBER_ATTRIBUTES_OF_GROUP(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SET_MEMBER_ATTRIBUTES_OF_GROUP *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SET_MEMBER_ATTRIBUTES_OF_GROUP, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SET_MEMBER_ATTRIBUTES_OF_GROUP, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SET_MEMBER_ATTRIBUTES_OF_GROUP,
 				    (ndr_pull_fn_t) ndr_pull_samr_SET_MEMBER_ATTRIBUTES_OF_GROUP,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SET_MEMBER_ATTRIBUTES_OF_GROUP, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_OpenAlias(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_OpenAlias *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_OpenAlias, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_OPENALIAS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_OpenAlias,
 				    (ndr_pull_fn_t) ndr_pull_samr_OpenAlias,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_OpenAlias, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QueryAliasInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QueryAliasInfo *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QueryAliasInfo, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERYALIASINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QueryAliasInfo,
 				    (ndr_pull_fn_t) ndr_pull_samr_QueryAliasInfo,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QueryAliasInfo, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SET_ALIASINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SET_ALIASINFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SET_ALIASINFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SET_ALIASINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SET_ALIASINFO,
 				    (ndr_pull_fn_t) ndr_pull_samr_SET_ALIASINFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SET_ALIASINFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_DELETE_DOM_ALIAS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_DELETE_DOM_ALIAS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_DELETE_DOM_ALIAS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_DELETE_DOM_ALIAS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_DELETE_DOM_ALIAS,
 				    (ndr_pull_fn_t) ndr_pull_samr_DELETE_DOM_ALIAS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_DELETE_DOM_ALIAS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_ADD_ALIASMEM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_ADD_ALIASMEM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_ADD_ALIASMEM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_ADD_ALIASMEM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_ADD_ALIASMEM,
 				    (ndr_pull_fn_t) ndr_pull_samr_ADD_ALIASMEM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_ADD_ALIASMEM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_DEL_ALIASMEM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_DEL_ALIASMEM *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_DEL_ALIASMEM, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_DEL_ALIASMEM, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_DEL_ALIASMEM,
 				    (ndr_pull_fn_t) ndr_pull_samr_DEL_ALIASMEM,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_DEL_ALIASMEM, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_GET_MEMBERS_IN_ALIAS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_MEMBERS_IN_ALIAS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_GET_MEMBERS_IN_ALIAS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_MEMBERS_IN_ALIAS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_GET_MEMBERS_IN_ALIAS,
 				    (ndr_pull_fn_t) ndr_pull_samr_GET_MEMBERS_IN_ALIAS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_GET_MEMBERS_IN_ALIAS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_OpenUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_OpenUser *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_OpenUser, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_OPENUSER, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_OpenUser,
 				    (ndr_pull_fn_t) ndr_pull_samr_OpenUser,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_OpenUser, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_DELETE_DOM_USER(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_DELETE_DOM_USER *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_DELETE_DOM_USER, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_DELETE_DOM_USER, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_DELETE_DOM_USER,
 				    (ndr_pull_fn_t) ndr_pull_samr_DELETE_DOM_USER,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_DELETE_DOM_USER, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QueryUserInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QueryUserInfo *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QueryUserInfo, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERYUSERINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QueryUserInfo,
 				    (ndr_pull_fn_t) ndr_pull_samr_QueryUserInfo,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SET_USERINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SET_USERINFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SET_USERINFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SET_USERINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SET_USERINFO,
 				    (ndr_pull_fn_t) ndr_pull_samr_SET_USERINFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SET_USERINFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_CHANGE_PASSWORD_USER(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CHANGE_PASSWORD_USER *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_CHANGE_PASSWORD_USER, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CHANGE_PASSWORD_USER, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_CHANGE_PASSWORD_USER,
 				    (ndr_pull_fn_t) ndr_pull_samr_CHANGE_PASSWORD_USER,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_CHANGE_PASSWORD_USER, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_GET_GROUPS_FOR_USER(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_GROUPS_FOR_USER *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_GET_GROUPS_FOR_USER, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_GROUPS_FOR_USER, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_GET_GROUPS_FOR_USER,
 				    (ndr_pull_fn_t) ndr_pull_samr_GET_GROUPS_FOR_USER,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_GET_GROUPS_FOR_USER, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QUERY_DISPINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QUERY_DISPINFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QUERY_DISPINFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERY_DISPINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QUERY_DISPINFO,
 				    (ndr_pull_fn_t) ndr_pull_samr_QUERY_DISPINFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QUERY_DISPINFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_GET_DISPLAY_ENUMERATION_INDEX(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_DISPLAY_ENUMERATION_INDEX *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_GET_DISPLAY_ENUMERATION_INDEX, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_DISPLAY_ENUMERATION_INDEX, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_GET_DISPLAY_ENUMERATION_INDEX,
 				    (ndr_pull_fn_t) ndr_pull_samr_GET_DISPLAY_ENUMERATION_INDEX,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_GET_DISPLAY_ENUMERATION_INDEX, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_TEST_PRIVATE_FUNCTIONS_DOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_TEST_PRIVATE_FUNCTIONS_DOMAIN *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_TEST_PRIVATE_FUNCTIONS_DOMAIN, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_TEST_PRIVATE_FUNCTIONS_DOMAIN, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_TEST_PRIVATE_FUNCTIONS_DOMAIN,
 				    (ndr_pull_fn_t) ndr_pull_samr_TEST_PRIVATE_FUNCTIONS_DOMAIN,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_TEST_PRIVATE_FUNCTIONS_DOMAIN, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_TEST_PRIVATE_FUNCTIONS_USER(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_TEST_PRIVATE_FUNCTIONS_USER *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_TEST_PRIVATE_FUNCTIONS_USER, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_TEST_PRIVATE_FUNCTIONS_USER, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_TEST_PRIVATE_FUNCTIONS_USER,
 				    (ndr_pull_fn_t) ndr_pull_samr_TEST_PRIVATE_FUNCTIONS_USER,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_TEST_PRIVATE_FUNCTIONS_USER, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_GET_USRDOM_PWINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_USRDOM_PWINFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_GET_USRDOM_PWINFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_USRDOM_PWINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_GET_USRDOM_PWINFO,
 				    (ndr_pull_fn_t) ndr_pull_samr_GET_USRDOM_PWINFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_GET_USRDOM_PWINFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_REMOVE_MEMBER_FROM_FOREIGN_DOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_REMOVE_MEMBER_FROM_FOREIGN_DOMAIN *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_REMOVE_MEMBER_FROM_FOREIGN_DOMAIN, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_REMOVE_MEMBER_FROM_FOREIGN_DOMAIN, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_REMOVE_MEMBER_FROM_FOREIGN_DOMAIN,
 				    (ndr_pull_fn_t) ndr_pull_samr_REMOVE_MEMBER_FROM_FOREIGN_DOMAIN,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_REMOVE_MEMBER_FROM_FOREIGN_DOMAIN, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QUERY_INFORMATION_DOMAIN2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QUERY_INFORMATION_DOMAIN2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QUERY_INFORMATION_DOMAIN2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERY_INFORMATION_DOMAIN2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QUERY_INFORMATION_DOMAIN2,
 				    (ndr_pull_fn_t) ndr_pull_samr_QUERY_INFORMATION_DOMAIN2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QUERY_INFORMATION_DOMAIN2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QUERY_INFORMATION_USER2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QUERY_INFORMATION_USER2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QUERY_INFORMATION_USER2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERY_INFORMATION_USER2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QUERY_INFORMATION_USER2,
 				    (ndr_pull_fn_t) ndr_pull_samr_QUERY_INFORMATION_USER2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QUERY_INFORMATION_USER2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QUERY_DISPINFO2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QUERY_DISPINFO2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QUERY_DISPINFO2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERY_DISPINFO2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QUERY_DISPINFO2,
 				    (ndr_pull_fn_t) ndr_pull_samr_QUERY_DISPINFO2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QUERY_DISPINFO2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_GET_DISPLAY_ENUMERATION_INDEX2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_DISPLAY_ENUMERATION_INDEX2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_GET_DISPLAY_ENUMERATION_INDEX2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_DISPLAY_ENUMERATION_INDEX2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_GET_DISPLAY_ENUMERATION_INDEX2,
 				    (ndr_pull_fn_t) ndr_pull_samr_GET_DISPLAY_ENUMERATION_INDEX2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_GET_DISPLAY_ENUMERATION_INDEX2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_CREATE_USER2_IN_DOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CREATE_USER2_IN_DOMAIN *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_CREATE_USER2_IN_DOMAIN, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CREATE_USER2_IN_DOMAIN, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_CREATE_USER2_IN_DOMAIN,
 				    (ndr_pull_fn_t) ndr_pull_samr_CREATE_USER2_IN_DOMAIN,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_CREATE_USER2_IN_DOMAIN, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_QUERY_DISPINFO3(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_QUERY_DISPINFO3 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_QUERY_DISPINFO3, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_QUERY_DISPINFO3, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_QUERY_DISPINFO3,
 				    (ndr_pull_fn_t) ndr_pull_samr_QUERY_DISPINFO3,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_QUERY_DISPINFO3, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_ADD_MULTIPLE_MEMBERS_TO_ALIAS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_ADD_MULTIPLE_MEMBERS_TO_ALIAS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_ADD_MULTIPLE_MEMBERS_TO_ALIAS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_ADD_MULTIPLE_MEMBERS_TO_ALIAS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_ADD_MULTIPLE_MEMBERS_TO_ALIAS,
 				    (ndr_pull_fn_t) ndr_pull_samr_ADD_MULTIPLE_MEMBERS_TO_ALIAS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_ADD_MULTIPLE_MEMBERS_TO_ALIAS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_REMOVE_MULTIPLE_MEMBERS_FROM_ALIAS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_REMOVE_MULTIPLE_MEMBERS_FROM_ALIAS *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_REMOVE_MULTIPLE_MEMBERS_FROM_ALIAS, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_REMOVE_MULTIPLE_MEMBERS_FROM_ALIAS, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_REMOVE_MULTIPLE_MEMBERS_FROM_ALIAS,
 				    (ndr_pull_fn_t) ndr_pull_samr_REMOVE_MULTIPLE_MEMBERS_FROM_ALIAS,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_REMOVE_MULTIPLE_MEMBERS_FROM_ALIAS, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_OEM_CHANGE_PASSWORD_USER2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_OEM_CHANGE_PASSWORD_USER2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_OEM_CHANGE_PASSWORD_USER2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_OEM_CHANGE_PASSWORD_USER2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_OEM_CHANGE_PASSWORD_USER2,
 				    (ndr_pull_fn_t) ndr_pull_samr_OEM_CHANGE_PASSWORD_USER2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_OEM_CHANGE_PASSWORD_USER2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_UNICODE_CHANGE_PASSWORD_USER2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_UNICODE_CHANGE_PASSWORD_USER2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_UNICODE_CHANGE_PASSWORD_USER2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_UNICODE_CHANGE_PASSWORD_USER2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_UNICODE_CHANGE_PASSWORD_USER2,
 				    (ndr_pull_fn_t) ndr_pull_samr_UNICODE_CHANGE_PASSWORD_USER2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_UNICODE_CHANGE_PASSWORD_USER2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_GET_DOM_PWINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_DOM_PWINFO *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_GET_DOM_PWINFO, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_DOM_PWINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_GET_DOM_PWINFO,
 				    (ndr_pull_fn_t) ndr_pull_samr_GET_DOM_PWINFO,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_GET_DOM_PWINFO, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_CONNECT2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CONNECT2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_CONNECT2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CONNECT2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_CONNECT2,
 				    (ndr_pull_fn_t) ndr_pull_samr_CONNECT2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_CONNECT2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SET_USERINFO2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SET_USERINFO2 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SET_USERINFO2, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SET_USERINFO2, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SET_USERINFO2,
 				    (ndr_pull_fn_t) ndr_pull_samr_SET_USERINFO2,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SET_USERINFO2, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SET_BOOT_KEY_INFORMATION(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SET_BOOT_KEY_INFORMATION *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SET_BOOT_KEY_INFORMATION, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SET_BOOT_KEY_INFORMATION, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SET_BOOT_KEY_INFORMATION,
 				    (ndr_pull_fn_t) ndr_pull_samr_SET_BOOT_KEY_INFORMATION,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SET_BOOT_KEY_INFORMATION, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_GET_BOOT_KEY_INFORMATION(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_BOOT_KEY_INFORMATION *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_GET_BOOT_KEY_INFORMATION, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_BOOT_KEY_INFORMATION, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_GET_BOOT_KEY_INFORMATION,
 				    (ndr_pull_fn_t) ndr_pull_samr_GET_BOOT_KEY_INFORMATION,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_GET_BOOT_KEY_INFORMATION, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_CONNECT3(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CONNECT3 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_CONNECT3, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CONNECT3, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_CONNECT3,
 				    (ndr_pull_fn_t) ndr_pull_samr_CONNECT3,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_CONNECT3, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_Connect4(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_Connect4 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_Connect4, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CONNECT4, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_Connect4,
 				    (ndr_pull_fn_t) ndr_pull_samr_Connect4,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_Connect4, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_UNICODE_CHANGE_PASSWORD_USER3(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_UNICODE_CHANGE_PASSWORD_USER3 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_UNICODE_CHANGE_PASSWORD_USER3, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_UNICODE_CHANGE_PASSWORD_USER3, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_UNICODE_CHANGE_PASSWORD_USER3,
 				    (ndr_pull_fn_t) ndr_pull_samr_UNICODE_CHANGE_PASSWORD_USER3,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_UNICODE_CHANGE_PASSWORD_USER3, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_CONNECT5(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CONNECT5 *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_CONNECT5, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_CONNECT5, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_CONNECT5,
 				    (ndr_pull_fn_t) ndr_pull_samr_CONNECT5,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_CONNECT5, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_RID_TO_SID(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_RID_TO_SID *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_RID_TO_SID, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_RID_TO_SID, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_RID_TO_SID,
 				    (ndr_pull_fn_t) ndr_pull_samr_RID_TO_SID,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_RID_TO_SID, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_SET_DSRM_PASSWORD(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_SET_DSRM_PASSWORD *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_SET_DSRM_PASSWORD, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_SET_DSRM_PASSWORD, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_SET_DSRM_PASSWORD,
 				    (ndr_pull_fn_t) ndr_pull_samr_SET_DSRM_PASSWORD,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_SET_DSRM_PASSWORD, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
 
 NTSTATUS dcerpc_samr_VALIDATE_PASSWORD(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_VALIDATE_PASSWORD *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(samr_VALIDATE_PASSWORD, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_SAMR_VALIDATE_PASSWORD, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_samr_VALIDATE_PASSWORD,
 				    (ndr_pull_fn_t) ndr_pull_samr_VALIDATE_PASSWORD,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(samr_VALIDATE_PASSWORD, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
diff --git a/source4/librpc/rpc/rpc_spoolss.c b/source4/librpc/rpc/rpc_spoolss.c
index 026798df70..19dd3be336 100644
--- a/source4/librpc/rpc/rpc_spoolss.c
+++ b/source4/librpc/rpc/rpc_spoolss.c
@@ -1,1318 +1,2015 @@
-/* dcerpc client calls auto-generated by pidl */
+/* 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)
 {
-	return 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);
+	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)
 {
-	return 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);
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_02, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_03, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_05, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_06, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_07, r);		
 	}
-	
-	return r->out.result;
+	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)
 {
-	return 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);
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_09, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_0a, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_0b, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_0c, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_0d, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_0e, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_0f, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_10, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_11, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_StartPagePrinter, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_13, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_EndPagePrinter, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_15, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_16, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_EndDocPrinter, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_18, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_19, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_1a, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_1b, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_1c, r);		
 	}
-	
-	return r->out.result;
+	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)
 {
-	return 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);
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_1e, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_1f, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_20, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_21, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_22, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_23, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_24, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_25, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_26, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_27, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_28, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_29, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_2a, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_2b, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_2c, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_2d, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_2e, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_2f, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_30, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_31, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_32, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_33, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_34, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_35, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_36, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_37, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_38, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_39, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_3a, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_3b, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_3c, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_3d, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_3e, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_3f, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_40, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_41, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_42, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_43, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_44, r);		
 	}
-	
-	return r->out.result;
+	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)
 {
-	return 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);
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_46, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_47, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterData, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_49, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_4a, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_4b, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_4c, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_4d, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_4e, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_4f, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_50, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_51, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_52, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_53, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_54, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_55, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_56, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_57, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_58, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_59, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_5a, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_5b, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_5c, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_5d, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_5e, r);		
 	}
-	
-	return r->out.result;
+	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)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(spoolss_5f, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }
diff --git a/source4/librpc/rpc/rpc_wkssvc.c b/source4/librpc/rpc/rpc_wkssvc.c
index 0549a35128..1a4b154842 100644
--- a/source4/librpc/rpc/rpc_wkssvc.c
+++ b/source4/librpc/rpc/rpc_wkssvc.c
@@ -1,4 +1,4 @@
-/* dcerpc client calls auto-generated by pidl */
+/* dcerpc client calls generated by pidl */
 
 #include "includes.h"
 
@@ -6,13 +6,20 @@
 NTSTATUS dcerpc_wks_QueryInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct wks_QueryInfo *r)
 {
 	NTSTATUS status;
+
+        if (p->flags & DCERPC_DEBUG_PRINT_IN) {
+		NDR_PRINT_IN_DEBUG(wks_QueryInfo, r);		
+	}
+
 	status = dcerpc_ndr_request(p, DCERPC_WKS_QUERYINFO, mem_ctx,
 				    (ndr_push_fn_t) ndr_push_wks_QueryInfo,
 				    (ndr_pull_fn_t) ndr_pull_wks_QueryInfo,
 				    r);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+
+        if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
+		NDR_PRINT_OUT_DEBUG(wks_QueryInfo, r);		
 	}
-	
-	return r->out.result;
+	if (NT_STATUS_IS_OK(status)) status = r->out.result;
+
+	return status;
 }