/* parser auto-generated by pidl */

#include "includes.h"
#include "bin/default/librpc/gen_ndr/ndr_efs.h"

#include "librpc/gen_ndr/ndr_security.h"
static enum ndr_err_code ndr_push_EFS_HASH_BLOB(struct ndr_push *ndr, int ndr_flags, const struct EFS_HASH_BLOB *r)
{
	NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_push_align(ndr, 5));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbData));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->pbData));
		NDR_CHECK(ndr_push_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->pbData) {
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbData));
			NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pbData, r->cbData));
		}
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EFS_HASH_BLOB(struct ndr_pull *ndr, int ndr_flags, struct EFS_HASH_BLOB *r)
{
	uint32_t _ptr_pbData;
	uint32_t size_pbData_1 = 0;
	TALLOC_CTX *_mem_save_pbData_0 = NULL;
	NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 5));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbData));
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pbData));
		if (_ptr_pbData) {
			NDR_PULL_ALLOC(ndr, r->pbData);
		} else {
			r->pbData = NULL;
		}
		NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->pbData) {
			_mem_save_pbData_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->pbData, 0);
			NDR_CHECK(ndr_pull_array_size(ndr, &r->pbData));
			size_pbData_1 = ndr_get_array_size(ndr, &r->pbData);
			NDR_PULL_ALLOC_N(ndr, r->pbData, size_pbData_1);
			NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pbData, size_pbData_1));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pbData_0, 0);
		}
		if (r->pbData) {
			NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pbData, r->cbData));
		}
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EFS_HASH_BLOB(struct ndr_print *ndr, const char *name, const struct EFS_HASH_BLOB *r)
{
	ndr_print_struct(ndr, name, "EFS_HASH_BLOB");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	ndr_print_uint32(ndr, "cbData", r->cbData);
	ndr_print_ptr(ndr, "pbData", r->pbData);
	ndr->depth++;
	if (r->pbData) {
		ndr_print_array_uint8(ndr, "pbData", r->pbData, r->cbData);
	}
	ndr->depth--;
	ndr->depth--;
}

static enum ndr_err_code ndr_push_ENCRYPTION_CERTIFICATE_HASH(struct ndr_push *ndr, int ndr_flags, const struct ENCRYPTION_CERTIFICATE_HASH *r)
{
	NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_push_align(ndr, 5));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbTotalLength));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->pUserSid));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->pHash));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpDisplayInformation));
		NDR_CHECK(ndr_push_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->pUserSid) {
			NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->pUserSid));
		}
		if (r->pHash) {
			NDR_CHECK(ndr_push_EFS_HASH_BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->pHash));
		}
		if (r->lpDisplayInformation) {
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpDisplayInformation, CH_UTF16)));
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpDisplayInformation, CH_UTF16)));
			NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpDisplayInformation, ndr_charset_length(r->lpDisplayInformation, CH_UTF16), sizeof(uint16_t), CH_UTF16));
		}
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_ENCRYPTION_CERTIFICATE_HASH(struct ndr_pull *ndr, int ndr_flags, struct ENCRYPTION_CERTIFICATE_HASH *r)
{
	uint32_t _ptr_pUserSid;
	TALLOC_CTX *_mem_save_pUserSid_0 = NULL;
	uint32_t _ptr_pHash;
	TALLOC_CTX *_mem_save_pHash_0 = NULL;
	uint32_t _ptr_lpDisplayInformation;
	uint32_t size_lpDisplayInformation_1 = 0;
	uint32_t length_lpDisplayInformation_1 = 0;
	TALLOC_CTX *_mem_save_lpDisplayInformation_0 = NULL;
	NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 5));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbTotalLength));
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pUserSid));
		if (_ptr_pUserSid) {
			NDR_PULL_ALLOC(ndr, r->pUserSid);
		} else {
			r->pUserSid = NULL;
		}
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pHash));
		if (_ptr_pHash) {
			NDR_PULL_ALLOC(ndr, r->pHash);
		} else {
			r->pHash = NULL;
		}
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpDisplayInformation));
		if (_ptr_lpDisplayInformation) {
			NDR_PULL_ALLOC(ndr, r->lpDisplayInformation);
		} else {
			r->lpDisplayInformation = NULL;
		}
		NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->pUserSid) {
			_mem_save_pUserSid_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->pUserSid, 0);
			NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->pUserSid));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUserSid_0, 0);
		}
		if (r->pHash) {
			_mem_save_pHash_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->pHash, 0);
			NDR_CHECK(ndr_pull_EFS_HASH_BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->pHash));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pHash_0, 0);
		}
		if (r->lpDisplayInformation) {
			_mem_save_lpDisplayInformation_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->lpDisplayInformation, 0);
			NDR_CHECK(ndr_pull_array_size(ndr, &r->lpDisplayInformation));
			NDR_CHECK(ndr_pull_array_length(ndr, &r->lpDisplayInformation));
			size_lpDisplayInformation_1 = ndr_get_array_size(ndr, &r->lpDisplayInformation);
			length_lpDisplayInformation_1 = ndr_get_array_length(ndr, &r->lpDisplayInformation);
			if (length_lpDisplayInformation_1 > size_lpDisplayInformation_1) {
				return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpDisplayInformation_1, length_lpDisplayInformation_1);
			}
			NDR_CHECK(ndr_check_string_terminator(ndr, length_lpDisplayInformation_1, sizeof(uint16_t)));
			NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpDisplayInformation, length_lpDisplayInformation_1, sizeof(uint16_t), CH_UTF16));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpDisplayInformation_0, 0);
		}
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_ENCRYPTION_CERTIFICATE_HASH(struct ndr_print *ndr, const char *name, const struct ENCRYPTION_CERTIFICATE_HASH *r)
{
	ndr_print_struct(ndr, name, "ENCRYPTION_CERTIFICATE_HASH");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	ndr_print_uint32(ndr, "cbTotalLength", r->cbTotalLength);
	ndr_print_ptr(ndr, "pUserSid", r->pUserSid);
	ndr->depth++;
	if (r->pUserSid) {
		ndr_print_dom_sid(ndr, "pUserSid", r->pUserSid);
	}
	ndr->depth--;
	ndr_print_ptr(ndr, "pHash", r->pHash);
	ndr->depth++;
	if (r->pHash) {
		ndr_print_EFS_HASH_BLOB(ndr, "pHash", r->pHash);
	}
	ndr->depth--;
	ndr_print_ptr(ndr, "lpDisplayInformation", r->lpDisplayInformation);
	ndr->depth++;
	if (r->lpDisplayInformation) {
		ndr_print_string(ndr, "lpDisplayInformation", r->lpDisplayInformation);
	}
	ndr->depth--;
	ndr->depth--;
}

static enum ndr_err_code ndr_push_ENCRYPTION_CERTIFICATE_HASH_LIST(struct ndr_push *ndr, int ndr_flags, const struct ENCRYPTION_CERTIFICATE_HASH_LIST *r)
{
	uint32_t cntr_pUsers_0;
	NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->nCert_Hash));
		NDR_CHECK(ndr_push_align(ndr, 5));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nCert_Hash));
		for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (r->nCert_Hash); cntr_pUsers_0++) {
			NDR_CHECK(ndr_push_unique_ptr(ndr, r->pUsers[cntr_pUsers_0]));
		}
		NDR_CHECK(ndr_push_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (r->nCert_Hash); cntr_pUsers_0++) {
			if (r->pUsers[cntr_pUsers_0]) {
				NDR_CHECK(ndr_push_ENCRYPTION_CERTIFICATE_HASH(ndr, NDR_SCALARS|NDR_BUFFERS, r->pUsers[cntr_pUsers_0]));
			}
		}
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_ENCRYPTION_CERTIFICATE_HASH_LIST(struct ndr_pull *ndr, int ndr_flags, struct ENCRYPTION_CERTIFICATE_HASH_LIST *r)
{
	uint32_t _ptr_pUsers;
	uint32_t size_pUsers_0 = 0;
	uint32_t cntr_pUsers_0;
	TALLOC_CTX *_mem_save_pUsers_0 = NULL;
	TALLOC_CTX *_mem_save_pUsers_1 = NULL;
	NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_array_size(ndr, &r->pUsers));
		NDR_CHECK(ndr_pull_align(ndr, 5));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nCert_Hash));
		size_pUsers_0 = ndr_get_array_size(ndr, &r->pUsers);
		NDR_PULL_ALLOC_N(ndr, r->pUsers, size_pUsers_0);
		_mem_save_pUsers_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->pUsers, 0);
		for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (size_pUsers_0); cntr_pUsers_0++) {
			NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pUsers));
			if (_ptr_pUsers) {
				NDR_PULL_ALLOC(ndr, r->pUsers[cntr_pUsers_0]);
			} else {
				r->pUsers[cntr_pUsers_0] = NULL;
			}
		}
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_0, 0);
		if (r->pUsers) {
			NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pUsers, r->nCert_Hash));
		}
		NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		size_pUsers_0 = ndr_get_array_size(ndr, &r->pUsers);
		_mem_save_pUsers_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->pUsers, 0);
		for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (size_pUsers_0); cntr_pUsers_0++) {
			if (r->pUsers[cntr_pUsers_0]) {
				_mem_save_pUsers_1 = NDR_PULL_GET_MEM_CTX(ndr);
				NDR_PULL_SET_MEM_CTX(ndr, r->pUsers[cntr_pUsers_0], 0);
				NDR_CHECK(ndr_pull_ENCRYPTION_CERTIFICATE_HASH(ndr, NDR_SCALARS|NDR_BUFFERS, r->pUsers[cntr_pUsers_0]));
				NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_1, 0);
			}
		}
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_0, 0);
		for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (size_pUsers_0); cntr_pUsers_0++) {
		}
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_ENCRYPTION_CERTIFICATE_HASH_LIST(struct ndr_print *ndr, const char *name, const struct ENCRYPTION_CERTIFICATE_HASH_LIST *r)
{
	uint32_t cntr_pUsers_0;
	ndr_print_struct(ndr, name, "ENCRYPTION_CERTIFICATE_HASH_LIST");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	ndr_print_uint32(ndr, "nCert_Hash", r->nCert_Hash);
	ndr->print(ndr, "%s: ARRAY(%d)", "pUsers", (int)r->nCert_Hash);
	ndr->depth++;
	for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (r->nCert_Hash); cntr_pUsers_0++) {
		ndr_print_ptr(ndr, "pUsers", r->pUsers[cntr_pUsers_0]);
		ndr->depth++;
		if (r->pUsers[cntr_pUsers_0]) {
			ndr_print_ENCRYPTION_CERTIFICATE_HASH(ndr, "pUsers", r->pUsers[cntr_pUsers_0]);
		}
		ndr->depth--;
	}
	ndr->depth--;
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EFS_CERTIFICATE_BLOB(struct ndr_push *ndr, int ndr_flags, const struct EFS_CERTIFICATE_BLOB *r)
{
	NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_push_align(ndr, 5));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwCertEncodingType));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbData));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->pbData));
		NDR_CHECK(ndr_push_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->pbData) {
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbData));
			NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pbData, r->cbData));
		}
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EFS_CERTIFICATE_BLOB(struct ndr_pull *ndr, int ndr_flags, struct EFS_CERTIFICATE_BLOB *r)
{
	uint32_t _ptr_pbData;
	uint32_t size_pbData_1 = 0;
	TALLOC_CTX *_mem_save_pbData_0 = NULL;
	NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 5));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwCertEncodingType));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbData));
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pbData));
		if (_ptr_pbData) {
			NDR_PULL_ALLOC(ndr, r->pbData);
		} else {
			r->pbData = NULL;
		}
		NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->pbData) {
			_mem_save_pbData_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->pbData, 0);
			NDR_CHECK(ndr_pull_array_size(ndr, &r->pbData));
			size_pbData_1 = ndr_get_array_size(ndr, &r->pbData);
			NDR_PULL_ALLOC_N(ndr, r->pbData, size_pbData_1);
			NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pbData, size_pbData_1));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pbData_0, 0);
		}
		if (r->pbData) {
			NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pbData, r->cbData));
		}
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EFS_CERTIFICATE_BLOB(struct ndr_print *ndr, const char *name, const struct EFS_CERTIFICATE_BLOB *r)
{
	ndr_print_struct(ndr, name, "EFS_CERTIFICATE_BLOB");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	ndr_print_uint32(ndr, "dwCertEncodingType", r->dwCertEncodingType);
	ndr_print_uint32(ndr, "cbData", r->cbData);
	ndr_print_ptr(ndr, "pbData", r->pbData);
	ndr->depth++;
	if (r->pbData) {
		ndr_print_array_uint8(ndr, "pbData", r->pbData, r->cbData);
	}
	ndr->depth--;
	ndr->depth--;
}

static enum ndr_err_code ndr_push_ENCRYPTION_CERTIFICATE(struct ndr_push *ndr, int ndr_flags, const struct ENCRYPTION_CERTIFICATE *r)
{
	NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_push_align(ndr, 5));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->TotalLength));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->pUserSid));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->pCertBlob));
		NDR_CHECK(ndr_push_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->pUserSid) {
			NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->pUserSid));
		}
		if (r->pCertBlob) {
			NDR_CHECK(ndr_push_EFS_CERTIFICATE_BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->pCertBlob));
		}
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_ENCRYPTION_CERTIFICATE(struct ndr_pull *ndr, int ndr_flags, struct ENCRYPTION_CERTIFICATE *r)
{
	uint32_t _ptr_pUserSid;
	TALLOC_CTX *_mem_save_pUserSid_0 = NULL;
	uint32_t _ptr_pCertBlob;
	TALLOC_CTX *_mem_save_pCertBlob_0 = NULL;
	NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 5));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->TotalLength));
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pUserSid));
		if (_ptr_pUserSid) {
			NDR_PULL_ALLOC(ndr, r->pUserSid);
		} else {
			r->pUserSid = NULL;
		}
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pCertBlob));
		if (_ptr_pCertBlob) {
			NDR_PULL_ALLOC(ndr, r->pCertBlob);
		} else {
			r->pCertBlob = NULL;
		}
		NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->pUserSid) {
			_mem_save_pUserSid_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->pUserSid, 0);
			NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->pUserSid));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUserSid_0, 0);
		}
		if (r->pCertBlob) {
			_mem_save_pCertBlob_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->pCertBlob, 0);
			NDR_CHECK(ndr_pull_EFS_CERTIFICATE_BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->pCertBlob));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pCertBlob_0, 0);
		}
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_ENCRYPTION_CERTIFICATE(struct ndr_print *ndr, const char *name, const struct ENCRYPTION_CERTIFICATE *r)
{
	ndr_print_struct(ndr, name, "ENCRYPTION_CERTIFICATE");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	ndr_print_uint32(ndr, "TotalLength", r->TotalLength);
	ndr_print_ptr(ndr, "pUserSid", r->pUserSid);
	ndr->depth++;
	if (r->pUserSid) {
		ndr_print_dom_sid(ndr, "pUserSid", r->pUserSid);
	}
	ndr->depth--;
	ndr_print_ptr(ndr, "pCertBlob", r->pCertBlob);
	ndr->depth++;
	if (r->pCertBlob) {
		ndr_print_EFS_CERTIFICATE_BLOB(ndr, "pCertBlob", r->pCertBlob);
	}
	ndr->depth--;
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcOpenFileRaw(struct ndr_push *ndr, int flags, const struct EfsRpcOpenFileRaw *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Flags));
	}
	if (flags & NDR_OUT) {
		if (r->out.pvContext == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.pvContext));
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcOpenFileRaw(struct ndr_pull *ndr, int flags, struct EfsRpcOpenFileRaw *r)
{
	uint32_t size_FileName_0 = 0;
	uint32_t length_FileName_0 = 0;
	TALLOC_CTX *_mem_save_pvContext_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
		size_FileName_0 = ndr_get_array_size(ndr, &r->in.FileName);
		length_FileName_0 = ndr_get_array_length(ndr, &r->in.FileName);
		if (length_FileName_0 > size_FileName_0) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Flags));
		NDR_PULL_ALLOC(ndr, r->out.pvContext);
		NDR_ZERO_STRUCTP(r->out.pvContext);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.pvContext);
		}
		_mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.pvContext, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.pvContext));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcOpenFileRaw(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcOpenFileRaw *r)
{
	ndr_print_struct(ndr, name, "EfsRpcOpenFileRaw");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcOpenFileRaw");
		ndr->depth++;
		ndr_print_string(ndr, "FileName", r->in.FileName);
		ndr_print_uint32(ndr, "Flags", r->in.Flags);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcOpenFileRaw");
		ndr->depth++;
		ndr_print_ptr(ndr, "pvContext", r->out.pvContext);
		ndr->depth++;
		ndr_print_policy_handle(ndr, "pvContext", r->out.pvContext);
		ndr->depth--;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcReadFileRaw(struct ndr_push *ndr, int flags, const struct EfsRpcReadFileRaw *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (r->in.pvContext == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcReadFileRaw(struct ndr_pull *ndr, int flags, struct EfsRpcReadFileRaw *r)
{
	TALLOC_CTX *_mem_save_pvContext_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->in.pvContext);
		}
		_mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->in.pvContext, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
		if (r->in.pvContext == NULL) {
			NDR_PULL_ALLOC(ndr, r->in.pvContext);
			NDR_ZERO_STRUCTP(r->in.pvContext);
		}
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcReadFileRaw(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcReadFileRaw *r)
{
	ndr_print_struct(ndr, name, "EfsRpcReadFileRaw");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcReadFileRaw");
		ndr->depth++;
		ndr_print_ptr(ndr, "pvContext", r->in.pvContext);
		ndr->depth++;
		ndr_print_policy_handle(ndr, "pvContext", r->in.pvContext);
		ndr->depth--;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcReadFileRaw");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcWriteFileRaw(struct ndr_push *ndr, int flags, const struct EfsRpcWriteFileRaw *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (r->in.pvContext == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcWriteFileRaw(struct ndr_pull *ndr, int flags, struct EfsRpcWriteFileRaw *r)
{
	TALLOC_CTX *_mem_save_pvContext_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->in.pvContext);
		}
		_mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->in.pvContext, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
		if (r->in.pvContext == NULL) {
			NDR_PULL_ALLOC(ndr, r->in.pvContext);
			NDR_ZERO_STRUCTP(r->in.pvContext);
		}
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcWriteFileRaw(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcWriteFileRaw *r)
{
	ndr_print_struct(ndr, name, "EfsRpcWriteFileRaw");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcWriteFileRaw");
		ndr->depth++;
		ndr_print_ptr(ndr, "pvContext", r->in.pvContext);
		ndr->depth++;
		ndr_print_policy_handle(ndr, "pvContext", r->in.pvContext);
		ndr->depth--;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcWriteFileRaw");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcCloseRaw(struct ndr_push *ndr, int flags, const struct EfsRpcCloseRaw *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (r->in.pvContext == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
	}
	if (flags & NDR_OUT) {
		if (r->out.pvContext == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.pvContext));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcCloseRaw(struct ndr_pull *ndr, int flags, struct EfsRpcCloseRaw *r)
{
	TALLOC_CTX *_mem_save_pvContext_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->in.pvContext);
		}
		_mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->in.pvContext, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_PULL_ALLOC(ndr, r->out.pvContext);
		*r->out.pvContext = *r->in.pvContext;
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
		if (r->in.pvContext == NULL) {
			NDR_PULL_ALLOC(ndr, r->in.pvContext);
			NDR_ZERO_STRUCTP(r->in.pvContext);
		}
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.pvContext);
		}
		_mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.pvContext, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.pvContext));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcCloseRaw(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcCloseRaw *r)
{
	ndr_print_struct(ndr, name, "EfsRpcCloseRaw");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcCloseRaw");
		ndr->depth++;
		ndr_print_ptr(ndr, "pvContext", r->in.pvContext);
		ndr->depth++;
		ndr_print_policy_handle(ndr, "pvContext", r->in.pvContext);
		ndr->depth--;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcCloseRaw");
		ndr->depth++;
		ndr_print_ptr(ndr, "pvContext", r->out.pvContext);
		ndr->depth++;
		ndr_print_policy_handle(ndr, "pvContext", r->out.pvContext);
		ndr->depth--;
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcEncryptFileSrv(struct ndr_push *ndr, int flags, const struct EfsRpcEncryptFileSrv *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Filename, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Filename, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Filename, ndr_charset_length(r->in.Filename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcEncryptFileSrv(struct ndr_pull *ndr, int flags, struct EfsRpcEncryptFileSrv *r)
{
	uint32_t size_Filename_0 = 0;
	uint32_t length_Filename_0 = 0;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Filename));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Filename));
		size_Filename_0 = ndr_get_array_size(ndr, &r->in.Filename);
		length_Filename_0 = ndr_get_array_length(ndr, &r->in.Filename);
		if (length_Filename_0 > size_Filename_0) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Filename_0, length_Filename_0);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_Filename_0, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Filename, length_Filename_0, sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcEncryptFileSrv(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcEncryptFileSrv *r)
{
	ndr_print_struct(ndr, name, "EfsRpcEncryptFileSrv");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcEncryptFileSrv");
		ndr->depth++;
		ndr_print_string(ndr, "Filename", r->in.Filename);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcEncryptFileSrv");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcDecryptFileSrv(struct ndr_push *ndr, int flags, const struct EfsRpcDecryptFileSrv *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcDecryptFileSrv(struct ndr_pull *ndr, int flags, struct EfsRpcDecryptFileSrv *r)
{
	uint32_t size_FileName_0 = 0;
	uint32_t length_FileName_0 = 0;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
		size_FileName_0 = ndr_get_array_size(ndr, &r->in.FileName);
		length_FileName_0 = ndr_get_array_length(ndr, &r->in.FileName);
		if (length_FileName_0 > size_FileName_0) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcDecryptFileSrv(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcDecryptFileSrv *r)
{
	ndr_print_struct(ndr, name, "EfsRpcDecryptFileSrv");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcDecryptFileSrv");
		ndr->depth++;
		ndr_print_string(ndr, "FileName", r->in.FileName);
		ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcDecryptFileSrv");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcQueryUsersOnFile(struct ndr_push *ndr, int flags, const struct EfsRpcQueryUsersOnFile *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		if (r->out.pUsers == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.pUsers));
		if (*r->out.pUsers) {
			NDR_CHECK(ndr_push_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.pUsers));
		}
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcQueryUsersOnFile(struct ndr_pull *ndr, int flags, struct EfsRpcQueryUsersOnFile *r)
{
	uint32_t size_FileName_0 = 0;
	uint32_t length_FileName_0 = 0;
	uint32_t _ptr_pUsers;
	TALLOC_CTX *_mem_save_pUsers_0 = NULL;
	TALLOC_CTX *_mem_save_pUsers_1 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
		size_FileName_0 = ndr_get_array_size(ndr, &r->in.FileName);
		length_FileName_0 = ndr_get_array_length(ndr, &r->in.FileName);
		if (length_FileName_0 > size_FileName_0) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
		NDR_PULL_ALLOC(ndr, r->out.pUsers);
		NDR_ZERO_STRUCTP(r->out.pUsers);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.pUsers);
		}
		_mem_save_pUsers_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.pUsers, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pUsers));
		if (_ptr_pUsers) {
			NDR_PULL_ALLOC(ndr, *r->out.pUsers);
		} else {
			*r->out.pUsers = NULL;
		}
		if (*r->out.pUsers) {
			_mem_save_pUsers_1 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, *r->out.pUsers, 0);
			NDR_CHECK(ndr_pull_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.pUsers));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_1, 0);
		}
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcQueryUsersOnFile(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcQueryUsersOnFile *r)
{
	ndr_print_struct(ndr, name, "EfsRpcQueryUsersOnFile");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcQueryUsersOnFile");
		ndr->depth++;
		ndr_print_string(ndr, "FileName", r->in.FileName);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcQueryUsersOnFile");
		ndr->depth++;
		ndr_print_ptr(ndr, "pUsers", r->out.pUsers);
		ndr->depth++;
		ndr_print_ptr(ndr, "pUsers", *r->out.pUsers);
		ndr->depth++;
		if (*r->out.pUsers) {
			ndr_print_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, "pUsers", *r->out.pUsers);
		}
		ndr->depth--;
		ndr->depth--;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcQueryRecoveryAgents(struct ndr_push *ndr, int flags, const struct EfsRpcQueryRecoveryAgents *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		if (r->out.pRecoveryAgents == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.pRecoveryAgents));
		if (*r->out.pRecoveryAgents) {
			NDR_CHECK(ndr_push_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.pRecoveryAgents));
		}
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcQueryRecoveryAgents(struct ndr_pull *ndr, int flags, struct EfsRpcQueryRecoveryAgents *r)
{
	uint32_t size_FileName_0 = 0;
	uint32_t length_FileName_0 = 0;
	uint32_t _ptr_pRecoveryAgents;
	TALLOC_CTX *_mem_save_pRecoveryAgents_0 = NULL;
	TALLOC_CTX *_mem_save_pRecoveryAgents_1 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
		size_FileName_0 = ndr_get_array_size(ndr, &r->in.FileName);
		length_FileName_0 = ndr_get_array_length(ndr, &r->in.FileName);
		if (length_FileName_0 > size_FileName_0) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
		NDR_PULL_ALLOC(ndr, r->out.pRecoveryAgents);
		NDR_ZERO_STRUCTP(r->out.pRecoveryAgents);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.pRecoveryAgents);
		}
		_mem_save_pRecoveryAgents_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.pRecoveryAgents, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pRecoveryAgents));
		if (_ptr_pRecoveryAgents) {
			NDR_PULL_ALLOC(ndr, *r->out.pRecoveryAgents);
		} else {
			*r->out.pRecoveryAgents = NULL;
		}
		if (*r->out.pRecoveryAgents) {
			_mem_save_pRecoveryAgents_1 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, *r->out.pRecoveryAgents, 0);
			NDR_CHECK(ndr_pull_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.pRecoveryAgents));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pRecoveryAgents_1, 0);
		}
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pRecoveryAgents_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcQueryRecoveryAgents(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcQueryRecoveryAgents *r)
{
	ndr_print_struct(ndr, name, "EfsRpcQueryRecoveryAgents");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcQueryRecoveryAgents");
		ndr->depth++;
		ndr_print_string(ndr, "FileName", r->in.FileName);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcQueryRecoveryAgents");
		ndr->depth++;
		ndr_print_ptr(ndr, "pRecoveryAgents", r->out.pRecoveryAgents);
		ndr->depth++;
		ndr_print_ptr(ndr, "pRecoveryAgents", *r->out.pRecoveryAgents);
		ndr->depth++;
		if (*r->out.pRecoveryAgents) {
			ndr_print_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, "pRecoveryAgents", *r->out.pRecoveryAgents);
		}
		ndr->depth--;
		ndr->depth--;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcRemoveUsersFromFile(struct ndr_push *ndr, int flags, const struct EfsRpcRemoveUsersFromFile *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcRemoveUsersFromFile(struct ndr_pull *ndr, int flags, struct EfsRpcRemoveUsersFromFile *r)
{
	uint32_t size_FileName_0 = 0;
	uint32_t length_FileName_0 = 0;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
		size_FileName_0 = ndr_get_array_size(ndr, &r->in.FileName);
		length_FileName_0 = ndr_get_array_length(ndr, &r->in.FileName);
		if (length_FileName_0 > size_FileName_0) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcRemoveUsersFromFile(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcRemoveUsersFromFile *r)
{
	ndr_print_struct(ndr, name, "EfsRpcRemoveUsersFromFile");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcRemoveUsersFromFile");
		ndr->depth++;
		ndr_print_string(ndr, "FileName", r->in.FileName);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcRemoveUsersFromFile");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcAddUsersToFile(struct ndr_push *ndr, int flags, const struct EfsRpcAddUsersToFile *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcAddUsersToFile(struct ndr_pull *ndr, int flags, struct EfsRpcAddUsersToFile *r)
{
	uint32_t size_FileName_0 = 0;
	uint32_t length_FileName_0 = 0;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
		size_FileName_0 = ndr_get_array_size(ndr, &r->in.FileName);
		length_FileName_0 = ndr_get_array_length(ndr, &r->in.FileName);
		if (length_FileName_0 > size_FileName_0) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcAddUsersToFile(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcAddUsersToFile *r)
{
	ndr_print_struct(ndr, name, "EfsRpcAddUsersToFile");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcAddUsersToFile");
		ndr->depth++;
		ndr_print_string(ndr, "FileName", r->in.FileName);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcAddUsersToFile");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcSetFileEncryptionKey(struct ndr_push *ndr, int flags, const struct EfsRpcSetFileEncryptionKey *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.pEncryptionCertificate));
		if (r->in.pEncryptionCertificate) {
			NDR_CHECK(ndr_push_ENCRYPTION_CERTIFICATE(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pEncryptionCertificate));
		}
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcSetFileEncryptionKey(struct ndr_pull *ndr, int flags, struct EfsRpcSetFileEncryptionKey *r)
{
	uint32_t _ptr_pEncryptionCertificate;
	TALLOC_CTX *_mem_save_pEncryptionCertificate_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pEncryptionCertificate));
		if (_ptr_pEncryptionCertificate) {
			NDR_PULL_ALLOC(ndr, r->in.pEncryptionCertificate);
		} else {
			r->in.pEncryptionCertificate = NULL;
		}
		if (r->in.pEncryptionCertificate) {
			_mem_save_pEncryptionCertificate_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->in.pEncryptionCertificate, 0);
			NDR_CHECK(ndr_pull_ENCRYPTION_CERTIFICATE(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pEncryptionCertificate));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pEncryptionCertificate_0, 0);
		}
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcSetFileEncryptionKey(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcSetFileEncryptionKey *r)
{
	ndr_print_struct(ndr, name, "EfsRpcSetFileEncryptionKey");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcSetFileEncryptionKey");
		ndr->depth++;
		ndr_print_ptr(ndr, "pEncryptionCertificate", r->in.pEncryptionCertificate);
		ndr->depth++;
		if (r->in.pEncryptionCertificate) {
			ndr_print_ENCRYPTION_CERTIFICATE(ndr, "pEncryptionCertificate", r->in.pEncryptionCertificate);
		}
		ndr->depth--;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcSetFileEncryptionKey");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcNotSupported(struct ndr_push *ndr, int flags, const struct EfsRpcNotSupported *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcNotSupported(struct ndr_pull *ndr, int flags, struct EfsRpcNotSupported *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcNotSupported(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcNotSupported *r)
{
	ndr_print_struct(ndr, name, "EfsRpcNotSupported");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcNotSupported");
		ndr->depth++;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcNotSupported");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcFileKeyInfo(struct ndr_push *ndr, int flags, const struct EfsRpcFileKeyInfo *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcFileKeyInfo(struct ndr_pull *ndr, int flags, struct EfsRpcFileKeyInfo *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcFileKeyInfo(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcFileKeyInfo *r)
{
	ndr_print_struct(ndr, name, "EfsRpcFileKeyInfo");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcFileKeyInfo");
		ndr->depth++;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcFileKeyInfo");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_EfsRpcDuplicateEncryptionInfoFile(struct ndr_push *ndr, int flags, const struct EfsRpcDuplicateEncryptionInfoFile *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_EfsRpcDuplicateEncryptionInfoFile(struct ndr_pull *ndr, int flags, struct EfsRpcDuplicateEncryptionInfoFile *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_EfsRpcDuplicateEncryptionInfoFile(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcDuplicateEncryptionInfoFile *r)
{
	ndr_print_struct(ndr, name, "EfsRpcDuplicateEncryptionInfoFile");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "EfsRpcDuplicateEncryptionInfoFile");
		ndr->depth++;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "EfsRpcDuplicateEncryptionInfoFile");
		ndr->depth++;
		ndr_print_WERROR(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

#ifndef SKIP_NDR_TABLE_efs
static const struct ndr_interface_public_struct efs_public_structs[] = {
	{ .name = NULL }
};

static const struct ndr_interface_call efs_calls[] = {
	{
		"EfsRpcOpenFileRaw",
		sizeof(struct EfsRpcOpenFileRaw),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcOpenFileRaw,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcOpenFileRaw,
		(ndr_print_function_t) ndr_print_EfsRpcOpenFileRaw,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcReadFileRaw",
		sizeof(struct EfsRpcReadFileRaw),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcReadFileRaw,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcReadFileRaw,
		(ndr_print_function_t) ndr_print_EfsRpcReadFileRaw,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcWriteFileRaw",
		sizeof(struct EfsRpcWriteFileRaw),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcWriteFileRaw,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcWriteFileRaw,
		(ndr_print_function_t) ndr_print_EfsRpcWriteFileRaw,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcCloseRaw",
		sizeof(struct EfsRpcCloseRaw),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcCloseRaw,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcCloseRaw,
		(ndr_print_function_t) ndr_print_EfsRpcCloseRaw,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcEncryptFileSrv",
		sizeof(struct EfsRpcEncryptFileSrv),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcEncryptFileSrv,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcEncryptFileSrv,
		(ndr_print_function_t) ndr_print_EfsRpcEncryptFileSrv,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcDecryptFileSrv",
		sizeof(struct EfsRpcDecryptFileSrv),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcDecryptFileSrv,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcDecryptFileSrv,
		(ndr_print_function_t) ndr_print_EfsRpcDecryptFileSrv,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcQueryUsersOnFile",
		sizeof(struct EfsRpcQueryUsersOnFile),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcQueryUsersOnFile,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcQueryUsersOnFile,
		(ndr_print_function_t) ndr_print_EfsRpcQueryUsersOnFile,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcQueryRecoveryAgents",
		sizeof(struct EfsRpcQueryRecoveryAgents),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcQueryRecoveryAgents,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcQueryRecoveryAgents,
		(ndr_print_function_t) ndr_print_EfsRpcQueryRecoveryAgents,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcRemoveUsersFromFile",
		sizeof(struct EfsRpcRemoveUsersFromFile),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcRemoveUsersFromFile,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcRemoveUsersFromFile,
		(ndr_print_function_t) ndr_print_EfsRpcRemoveUsersFromFile,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcAddUsersToFile",
		sizeof(struct EfsRpcAddUsersToFile),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcAddUsersToFile,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcAddUsersToFile,
		(ndr_print_function_t) ndr_print_EfsRpcAddUsersToFile,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcSetFileEncryptionKey",
		sizeof(struct EfsRpcSetFileEncryptionKey),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcSetFileEncryptionKey,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcSetFileEncryptionKey,
		(ndr_print_function_t) ndr_print_EfsRpcSetFileEncryptionKey,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcNotSupported",
		sizeof(struct EfsRpcNotSupported),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcNotSupported,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcNotSupported,
		(ndr_print_function_t) ndr_print_EfsRpcNotSupported,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcFileKeyInfo",
		sizeof(struct EfsRpcFileKeyInfo),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcFileKeyInfo,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcFileKeyInfo,
		(ndr_print_function_t) ndr_print_EfsRpcFileKeyInfo,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"EfsRpcDuplicateEncryptionInfoFile",
		sizeof(struct EfsRpcDuplicateEncryptionInfoFile),
		(ndr_push_flags_fn_t) ndr_push_EfsRpcDuplicateEncryptionInfoFile,
		(ndr_pull_flags_fn_t) ndr_pull_EfsRpcDuplicateEncryptionInfoFile,
		(ndr_print_function_t) ndr_print_EfsRpcDuplicateEncryptionInfoFile,
		{ 0, NULL },
		{ 0, NULL },
	},
	{ .name = NULL }
};

static const char * const efs_endpoint_strings[] = {
	"ncacn_np:[\\pipe\\efs]", 
};

static const struct ndr_interface_string_array efs_endpoints = {
	.count	= 1,
	.names	= efs_endpoint_strings
};

static const char * const efs_authservice_strings[] = {
	"host", 
};

static const struct ndr_interface_string_array efs_authservices = {
	.count	= 1,
	.names	= efs_authservice_strings
};


const struct ndr_interface_table ndr_table_efs = {
	.name		= "efs",
	.syntax_id	= {
		{0xc681d488,0xd850,0x11d0,{0x8c,0x52},{0x00,0xc0,0x4f,0xd9,0x0f,0x7e}},
		NDR_EFS_VERSION
	},
	.helpstring	= NDR_EFS_HELPSTRING,
	.num_calls	= 14,
	.calls		= efs_calls,
	.num_public_structs	= 0,
	.public_structs		= efs_public_structs,
	.endpoints	= &efs_endpoints,
	.authservices	= &efs_authservices
};

#endif /* SKIP_NDR_TABLE_efs */