s4-idl: get rid of the operation specific DRS options flags
[metze/samba/wip.git] / librpc / gen_ndr / ndr_drsuapi.c
index c2a4aee180c859a5003a03a75822ac1a5fb88052..3b8ac3d751d89fdcf73ef1c33a29d322f6214b2d 100644 (file)
@@ -1,12 +1,71 @@
 /* parser auto-generated by pidl */
 
 #include "includes.h"
-#include "librpc/gen_ndr/ndr_drsuapi.h"
+#include "../librpc/gen_ndr/ndr_drsuapi.h"
 
 #include "librpc/gen_ndr/ndr_security.h"
 #include "librpc/gen_ndr/ndr_misc.h"
 #include "librpc/gen_ndr/ndr_samr.h"
 #include "librpc/ndr/ndr_compression.h"
+_PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DrsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
+{
+       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DrsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DrsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
+{
+       ndr_print_uint32(ndr, name, r);
+       ndr->depth++;
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_OP", DRSUAPI_DRS_ASYNC_OP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GETCHG_CHECK", DRSUAPI_DRS_GETCHG_CHECK, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_UPDATE_NOTIFICATION", DRSUAPI_DRS_UPDATE_NOTIFICATION, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ADD_REF", DRSUAPI_DRS_ADD_REF, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_ALL", DRSUAPI_DRS_SYNC_ALL, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DEL_REF", DRSUAPI_DRS_DEL_REF, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_WRIT_REP", DRSUAPI_DRS_WRIT_REP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC", DRSUAPI_DRS_INIT_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PER_SYNC", DRSUAPI_DRS_PER_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_MAIL_REP", DRSUAPI_DRS_MAIL_REP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_REP", DRSUAPI_DRS_ASYNC_REP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_IGNORE_ERROR", DRSUAPI_DRS_IGNORE_ERROR, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_TWOWAY_SYNC", DRSUAPI_DRS_TWOWAY_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_CRITICAL_ONLY", DRSUAPI_DRS_CRITICAL_ONLY, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ANC", DRSUAPI_DRS_GET_ANC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_NC_SIZE", DRSUAPI_DRS_GET_NC_SIZE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_LOCAL_ONLY", DRSUAPI_DRS_LOCAL_ONLY, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_BYNAME", DRSUAPI_DRS_SYNC_BYNAME, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_OK", DRSUAPI_DRS_REF_OK, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_NOW", DRSUAPI_DRS_FULL_SYNC_NOW, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_SOURCE", DRSUAPI_DRS_NO_SOURCE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS", DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_PACKET", DRSUAPI_DRS_FULL_SYNC_PACKET, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_REQUEUE", DRSUAPI_DRS_SYNC_REQUEUE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_URGENT", DRSUAPI_DRS_SYNC_URGENT, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_GCSPN", DRSUAPI_DRS_REF_GCSPN, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_DISCARD", DRSUAPI_DRS_NO_DISCARD, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_SYNCED", DRSUAPI_DRS_NEVER_SYNCED, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING", DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC_NOW", DRSUAPI_DRS_INIT_SYNC_NOW, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PREEMPTED", DRSUAPI_DRS_PREEMPTED, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_FORCED", DRSUAPI_DRS_SYNC_FORCED, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_AUTO_SYNC", DRSUAPI_DRS_DISABLE_AUTO_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_PERIODIC_SYNC", DRSUAPI_DRS_DISABLE_PERIODIC_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_USE_COMPRESSION", DRSUAPI_DRS_USE_COMPRESSION, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_NOTIFY", DRSUAPI_DRS_NEVER_NOTIFY, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_PAS", DRSUAPI_DRS_SYNC_PAS, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP", DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP, r);
+       ndr->depth--;
+}
+
 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 {
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
@@ -92,6 +151,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -105,6 +165,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -129,6 +190,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -143,6 +205,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -170,6 +233,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
                NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -186,6 +250,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
                NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -215,6 +280,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *nd
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -231,6 +297,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *nd
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -249,6 +316,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int n
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_union_align(ndr, 1));
                switch (level) {
                        case 24: {
                                {
@@ -313,6 +381,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int n
        int level;
        level = ndr_pull_get_switch_value(ndr, r);
        if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_union_align(ndr, 1));
                switch (level) {
                        case 24: {
                                {
@@ -403,6 +472,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
                NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -419,6 +489,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, in
                }
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
                NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -438,14 +509,15 @@ _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
                NDR_CHECK(ndr_push_align(ndr, 4));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->flags) - 4));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -467,6 +539,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr
                if (r->dn) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -478,7 +551,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr,
 {
        ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
        ndr->depth++;
-       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->flags) - 4:r->__ndr_size);
+       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4:r->__ndr_size);
        ndr_print_uint32(ndr, "__ndr_size_sid", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid28(&r->sid, ndr->flags):r->__ndr_size_sid);
        ndr_print_GUID(ndr, "guid", &r->guid);
        ndr_print_dom_sid28(ndr, "sid", &r->sid);
@@ -487,9 +560,9 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr,
        ndr->depth--;
 }
 
-_PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, int flags)
+_PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 {
-       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier);
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 }
 
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
@@ -540,7 +613,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, cons
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
                {
@@ -549,7 +622,8 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
                        ndr->flags = _flags_save_string;
                }
-               NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -574,7 +648,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull
        uint32_t _ptr_other_info;
        TALLOC_CTX *_mem_save_other_info_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
                if (_ptr_naming_context) {
                        NDR_PULL_ALLOC(ndr, r->naming_context);
@@ -593,7 +667,8 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull
                        }
                        ndr->flags = _flags_save_string;
                }
-               NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -634,7 +709,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, con
                ndr_print_string(ndr, "other_info", r->other_info);
        }
        ndr->depth--;
-       ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "options", r->options);
+       ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
        ndr->depth--;
 }
 
@@ -643,13 +718,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -660,7 +736,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -674,15 +750,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -692,7 +769,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -720,6 +797,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_pu
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -733,6 +811,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pu
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -755,6 +834,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -767,6 +847,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -786,7 +867,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *
 {
        uint32_t cntr_cursors_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
@@ -795,6 +876,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *
                for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -811,7 +893,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 0x100000) {
+               if (r->count > 0x100000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
@@ -825,6 +907,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *
                if (r->cursors) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -875,11 +958,15 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourFlags(struct ndr_print *ndr, c
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP", DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS", DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_USE_ASYNC_INTERSIDE_TRANSPORT", DRSUAPI_DS_REPLICA_NEIGHBOUR_USE_ASYNC_INTERSIDE_TRANSPORT, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP", DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_ERROR", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_ERROR, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY", DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS", DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_NEXT_PACKET", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_NEXT_PACKET, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED", DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING", DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED", DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS, r);
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC, r);
@@ -894,7 +981,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *n
        {
                uint32_t _flags_save_ENUM = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+               NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
                ndr->flags = _flags_save_ENUM;
        }
        return NDR_ERR_SUCCESS;
@@ -906,7 +993,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *n
        {
                uint32_t _flags_save_ENUM = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+               NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
                *r = v;
                ndr->flags = _flags_save_ENUM;
        }
@@ -940,7 +1027,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr,
        {
                uint32_t _flags_save_ENUM = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+               NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
                ndr->flags = _flags_save_ENUM;
        }
        return NDR_ERR_SUCCESS;
@@ -952,7 +1039,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr,
        {
                uint32_t _flags_save_ENUM = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+               NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
                *r = v;
                ndr->flags = _flags_save_ENUM;
        }
@@ -1007,6 +1094,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
                NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -1045,6 +1133,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
                NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -1086,26 +1175,64 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, co
        ndr->depth--;
 }
 
-_PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
 {
-       ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
-       ndr->depth++;
-       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0):r->__ndr_size);
-       ndr_print_ptr(ndr, "oid", r->oid);
-       ndr->depth++;
-       if (r->oid) {
-               ndr_print_string(ndr, "oid", r->oid);
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
-       ndr->depth--;
-       ndr->depth--;
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->binary_oid) {
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
+                       NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
+{
+       uint32_t _ptr_binary_oid;
+       TALLOC_CTX *_mem_save_binary_oid_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
+               if (r->length > 10000) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
+               if (_ptr_binary_oid) {
+                       NDR_PULL_ALLOC(ndr, r->binary_oid);
+               } else {
+                       r->binary_oid = NULL;
+               }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->binary_oid) {
+                       _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
+                       NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
+                       NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
+               }
+               if (r->binary_oid) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
+               }
+       }
+       return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
@@ -1116,9 +1243,10 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *n
 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
@@ -1139,13 +1267,14 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_p
 {
        uint32_t cntr_mappings_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->mappings) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
                        for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
                        }
@@ -1164,9 +1293,9 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_p
        TALLOC_CTX *_mem_save_mappings_0;
        TALLOC_CTX *_mem_save_mappings_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
-               if (r->num_mappings < 0 || r->num_mappings > 0x100000) {
+               if (r->num_mappings > 0x100000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
@@ -1175,6 +1304,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_p
                } else {
                        r->mappings = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->mappings) {
@@ -1229,7 +1359,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr,
        {
                uint32_t _flags_save_ENUM = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+               NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
                ndr->flags = _flags_save_ENUM;
        }
        return NDR_ERR_SUCCESS;
@@ -1241,7 +1371,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr,
        {
                uint32_t _flags_save_ENUM = ndr->flags;
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+               NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
                *r = v;
                ndr->flags = _flags_save_ENUM;
        }
@@ -1257,12 +1387,18 @@ _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                switch (r) {
                        case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
+                       case DRSUAPI_ATTRIBUTE_cn: val = "DRSUAPI_ATTRIBUTE_cn"; break;
                        case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
                        case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
                        case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
                        case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
+                       case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
                        case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
+                       case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
                        case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
+                       case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
+                       case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
+                       case DRSUAPI_ATTRIBUTE_rDNAttId: val = "DRSUAPI_ATTRIBUTE_rDNAttId"; break;
                        case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
                        case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
                        case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
@@ -1277,6 +1413,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char
                        case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
                        case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
                        case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
+                       case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
                        case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
                        case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
                        case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
@@ -1297,6 +1434,10 @@ _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char
                        case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
                        case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
                        case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
+                       case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
+                       case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
+                       case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
+                       case DRSUAPI_ATTRIBUTE_systemAuxiliaryClass: val = "DRSUAPI_ATTRIBUTE_systemAuxiliaryClass"; break;
                        case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
                        case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
                        case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
@@ -1313,10 +1454,12 @@ _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char
                        case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
                        case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
                        case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
+                       case DRSUAPI_ATTRIBUTE_transportAddressAttribute: val = "DRSUAPI_ATTRIBUTE_transportAddressAttribute"; break;
                        case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
                        case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
                        case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
                        case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
+                       case DRSUAPI_ATTRIBUTE_NONE: val = "DRSUAPI_ATTRIBUTE_NONE"; break;
                }
                ndr_print_enum(ndr, name, "ENUM", val, r);
                ndr->flags = _flags_save_ENUM;
@@ -1327,7 +1470,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push
 {
        uint32_t cntr_attids_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
@@ -1335,6 +1478,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push
                for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1364,6 +1508,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull
                if (r->attids) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1411,6 +1556,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
@@ -1473,6 +1619,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull
                        r->partial_attribute_set_ex = NULL;
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -1540,11 +1687,166 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, co
        ndr->depth--;
 }
 
+static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 8));
+               NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
+               NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
+               if (r->naming_context == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_ref_ptr(ndr));
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
+               NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
+               NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               if (r->uptodateness_vector) {
+                       NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
+               }
+               if (r->partial_attribute_set) {
+                       NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
+               }
+               if (r->partial_attribute_set_ex) {
+                       NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
+               }
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
+{
+       uint32_t _ptr_naming_context;
+       TALLOC_CTX *_mem_save_naming_context_0;
+       uint32_t _ptr_uptodateness_vector;
+       TALLOC_CTX *_mem_save_uptodateness_vector_0;
+       uint32_t _ptr_partial_attribute_set;
+       TALLOC_CTX *_mem_save_partial_attribute_set_0;
+       uint32_t _ptr_partial_attribute_set_ex;
+       TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 8));
+               NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
+               NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
+               NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
+               if (_ptr_naming_context) {
+                       NDR_PULL_ALLOC(ndr, r->naming_context);
+               } else {
+                       r->naming_context = NULL;
+               }
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
+               if (_ptr_uptodateness_vector) {
+                       NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
+               } else {
+                       r->uptodateness_vector = NULL;
+               }
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
+               NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
+               NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
+               if (_ptr_partial_attribute_set) {
+                       NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
+               } else {
+                       r->partial_attribute_set = NULL;
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
+               if (_ptr_partial_attribute_set_ex) {
+                       NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
+               } else {
+                       r->partial_attribute_set_ex = NULL;
+               }
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
+               if (r->uptodateness_vector) {
+                       _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
+                       NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
+               }
+               if (r->partial_attribute_set) {
+                       _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
+                       NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
+               }
+               if (r->partial_attribute_set_ex) {
+                       _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
+                       NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
+               }
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
+{
+       ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
+       ndr->depth++;
+       ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
+       ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
+       ndr_print_ptr(ndr, "naming_context", r->naming_context);
+       ndr->depth++;
+       ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
+       ndr->depth--;
+       ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
+       ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
+       ndr->depth++;
+       if (r->uptodateness_vector) {
+               ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
+       }
+       ndr->depth--;
+       ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
+       ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
+       ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
+       ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
+       ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
+       ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
+       ndr->depth++;
+       if (r->partial_attribute_set) {
+               ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
+       }
+       ndr->depth--;
+       ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
+       ndr->depth++;
+       if (r->partial_attribute_set_ex) {
+               ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
+       }
+       ndr->depth--;
+       ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
+       ndr_print_uint32(ndr, "more_flags", r->more_flags);
+       ndr->depth--;
+}
+
 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 5: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
@@ -1554,8 +1856,12 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push
                                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
                        break; }
 
+                       case 10: {
+                               NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
+                       break; }
+
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -1569,8 +1875,12 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push
                                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
                        break;
 
+                       case 10:
+                               NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
+                       break;
+
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -1584,8 +1894,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 5: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
@@ -1595,8 +1906,12 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
                        break; }
 
+                       case 10: {
+                               NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
+                       break; }
+
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -1609,8 +1924,12 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
                        break;
 
+                       case 10:
+                               NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
+                       break;
+
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -1630,6 +1949,10 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, con
                        ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
                break;
 
+               case 10:
+                       ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
+               break;
+
                default:
                        ndr_print_bad_level(ndr, name, level);
        }
@@ -1642,6 +1965,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *nd
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1655,6 +1979,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1675,7 +2000,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push
 {
        uint32_t cntr_cursors_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
@@ -1684,6 +2009,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push
                for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1700,7 +2026,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 0x100000) {
+               if (r->count > 0x100000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
@@ -1714,6 +2040,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull
                if (r->cursors) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -1745,9 +2072,10 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, con
 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->blob) {
@@ -1762,9 +2090,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr,
        uint32_t _ptr_blob;
        TALLOC_CTX *_mem_save_blob_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
-               if (r->__ndr_size < 0 || r->__ndr_size > 10485760) {
+               if (r->__ndr_size > 10485760) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
@@ -1773,6 +2101,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr,
                } else {
                        r->blob = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->blob) {
@@ -1803,13 +2132,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *n
 {
        uint32_t cntr_values_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->values) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
                        for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
                        }
@@ -1828,9 +2158,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *n
        TALLOC_CTX *_mem_save_values_0;
        TALLOC_CTX *_mem_save_values_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
-               if (r->num_values < 0 || r->num_values > 10485760) {
+               if (r->num_values > 10485760) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
@@ -1839,6 +2169,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *n
                } else {
                        r->values = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->values) {
@@ -1892,12 +2223,13 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct nd
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->flags)));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -1915,6 +2247,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct nd
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -1926,7 +2259,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr
 {
        ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
        ndr->depth++;
-       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->flags):r->__ndr_size);
+       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
        ndr_print_uint32(ndr, "__ndr_size_sid", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid28(&r->sid, ndr->flags):r->__ndr_size_sid);
        ndr_print_GUID(ndr, "guid", &r->guid);
        ndr_print_dom_sid28(ndr, "sid", &r->sid);
@@ -1935,16 +2268,16 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr
        ndr->depth--;
 }
 
-_PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, int flags)
+_PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
 {
-       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
 }
 
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->flags)));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags)));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
@@ -1957,6 +2290,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(str
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -1981,6 +2315,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(str
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
                        ndr->flags = _flags_save_DATA_BLOB;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -1992,7 +2327,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_prin
 {
        ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
        ndr->depth++;
-       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->flags):r->__ndr_size);
+       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
        ndr_print_uint32(ndr, "__ndr_size_sid", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid28(&r->sid, ndr->flags):r->__ndr_size_sid);
        ndr_print_GUID(ndr, "guid", &r->guid);
        ndr_print_dom_sid28(ndr, "sid", &r->sid);
@@ -2003,17 +2338,13 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_prin
        ndr->depth--;
 }
 
-_PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, int flags)
-{
-       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
-}
-
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
                NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
@@ -2024,9 +2355,10 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *
 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
                NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
@@ -2047,13 +2379,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push
 {
        uint32_t cntr_attributes_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attributes) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
                        for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
                        }
@@ -2072,9 +2405,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull
        TALLOC_CTX *_mem_save_attributes_0;
        TALLOC_CTX *_mem_save_attributes_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
-               if (r->num_attributes < 0 || r->num_attributes > 1048576) {
+               if (r->num_attributes > 1048576) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
@@ -2083,6 +2416,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull
                } else {
                        r->attributes = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attributes) {
@@ -2159,10 +2493,11 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, cons
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->identifier) {
@@ -2178,7 +2513,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr
        uint32_t _ptr_identifier;
        TALLOC_CTX *_mem_save_identifier_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
                if (_ptr_identifier) {
                        NDR_PULL_ALLOC(ndr, r->identifier);
@@ -2187,6 +2522,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->identifier) {
@@ -2223,6 +2559,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr
                NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2237,6 +2574,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr
                NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2258,12 +2596,13 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push
 {
        uint32_t cntr_meta_data_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2278,7 +2617,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull
                NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 1048576) {
+               if (r->count > 1048576) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
@@ -2291,6 +2630,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull
                if (r->meta_data) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2319,12 +2659,13 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, cons
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next_object) {
@@ -2350,7 +2691,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr
        uint32_t _ptr_meta_data_ctr;
        TALLOC_CTX *_mem_save_meta_data_ctr_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
                if (_ptr_next_object) {
                        NDR_PULL_ALLOC(ndr, r->next_object);
@@ -2371,6 +2712,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr
                } else {
                        r->meta_data_ctr = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next_object) {
@@ -2409,9 +2751,10 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
                NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->flags) + 55));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -2465,6 +2808,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *
                        r->first_object = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -2513,7 +2857,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const
        ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
        ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
        ndr_print_uint32(ndr, "object_count", r->object_count);
-       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->flags) + 55:r->__ndr_size);
+       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55:r->__ndr_size);
        ndr_print_ptr(ndr, "first_object", r->first_object);
        ndr->depth++;
        if (r->first_object) {
@@ -2524,9 +2868,9 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const
        ndr->depth--;
 }
 
-_PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, int flags)
+_PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
 {
-       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1);
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
 }
 
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
@@ -2561,6 +2905,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_
                NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->identifier) {
@@ -2588,6 +2933,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_
                NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
                NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->identifier) {
@@ -2633,7 +2979,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
                NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->flags) + 55));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
@@ -2641,6 +2987,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -2654,7 +3001,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
                }
                if (r->linked_attributes) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
                        for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
                        }
@@ -2710,7 +3057,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
-               if (r->linked_attributes_count < 0 || r->linked_attributes_count > 1048576) {
+               if (r->linked_attributes_count > 1048576) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
@@ -2720,6 +3067,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *
                        r->linked_attributes = NULL;
                }
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context) {
@@ -2788,7 +3136,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const
        ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
        ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
        ndr_print_uint32(ndr, "object_count", r->object_count);
-       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->flags) + 55:r->__ndr_size);
+       ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55:r->__ndr_size);
        ndr_print_ptr(ndr, "first_object", r->first_object);
        ndr->depth++;
        if (r->first_object) {
@@ -2818,9 +3166,9 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const
        ndr->depth--;
 }
 
-_PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, int flags)
+_PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
 {
-       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6);
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
 }
 
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
@@ -2833,6 +3181,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push
                        NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2849,6 +3198,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull
                        NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2873,6 +3223,7 @@ _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push
                        NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2889,6 +3240,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull
                        NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -2908,7 +3260,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pul
        uint32_t _ptr_ts;
        TALLOC_CTX *_mem_save_ts_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
@@ -2917,6 +3269,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pul
                } else {
                        r->ts = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ts) {
@@ -2959,7 +3312,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pul
        uint32_t _ptr_ts;
        TALLOC_CTX *_mem_save_ts_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
@@ -2968,6 +3321,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pul
                } else {
                        r->ts = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ts) {
@@ -3010,7 +3364,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pu
        uint32_t _ptr_ts;
        TALLOC_CTX *_mem_save_ts_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
@@ -3019,6 +3373,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pu
                } else {
                        r->ts = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ts) {
@@ -3061,7 +3416,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pu
        uint32_t _ptr_ts;
        TALLOC_CTX *_mem_save_ts_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
@@ -3070,6 +3425,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pu
                } else {
                        r->ts = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->ts) {
@@ -3109,14 +3465,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr,
 
 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
 {
-       NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -3139,6 +3495,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                if (ndr_flags & NDR_SCALARS) {
                        int level = ndr_push_get_switch_value(ndr, r);
+                       NDR_CHECK(ndr_push_union_align(ndr, 5));
                        switch (level) {
                                case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
                                        NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
@@ -3157,7 +3514,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr
                                break; }
 
                                default:
-                                       return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                                       return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                        }
                }
                if (ndr_flags & NDR_BUFFERS) {
@@ -3180,7 +3537,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr
                                break;
 
                                default:
-                                       return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                                       return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                        }
                }
                ndr->flags = _flags_save_UNION;
@@ -3196,6 +3553,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
                level = ndr_pull_get_switch_value(ndr, r);
                if (ndr_flags & NDR_SCALARS) {
+                       NDR_CHECK(ndr_pull_union_align(ndr, 5));
                        switch (level) {
                                case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
                                        NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
@@ -3214,7 +3572,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr
                                break; }
 
                                default:
-                                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                        }
                }
                if (ndr_flags & NDR_BUFFERS) {
@@ -3236,7 +3594,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr
                                break;
 
                                default:
-                                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                        }
                }
                ndr->flags = _flags_save_UNION;
@@ -3279,8 +3637,9 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *nd
 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
@@ -3291,8 +3650,9 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *nd
 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
@@ -3311,11 +3671,12 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const
 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -3326,7 +3687,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *nd
 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
                if (r->level < 0 || r->level > 6) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
@@ -3337,6 +3698,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *nd
                }
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
@@ -3360,6 +3722,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -3378,7 +3741,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -3401,7 +3764,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -3415,8 +3778,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -3435,7 +3799,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -3457,7 +3821,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -3490,36 +3854,10 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const c
        }
 }
 
-static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
-{
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
-       return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
-{
-       uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
-       *r = v;
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
-{
-       ndr_print_uint32(ndr, name, r);
-       ndr->depth++;
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_0x00000010", DRSUAPI_DS_REPLICA_UPDATE_0x00000010, r);
-       ndr->depth--;
-}
-
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                if (r->naming_context == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
@@ -3529,13 +3867,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr
                }
                NDR_CHECK(ndr_push_ref_ptr(ndr));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
-               NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dest_dsa_dns_name, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS), sizeof(uint8_t), CH_DOS));
        }
        return NDR_ERR_SUCCESS;
@@ -3547,84 +3886,747 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr
        TALLOC_CTX *_mem_save_naming_context_0;
        uint32_t _ptr_dest_dsa_dns_name;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
+               if (_ptr_naming_context) {
+                       NDR_PULL_ALLOC(ndr, r->naming_context);
+               } else {
+                       r->naming_context = NULL;
+               }
+               NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
+               if (_ptr_dest_dsa_dns_name) {
+                       NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
+               } else {
+                       r->dest_dsa_dns_name = NULL;
+               }
+               NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
+               NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
+               NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
+               NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
+               if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
+                       return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dest_dsa_dns_name), ndr_get_array_length(ndr, &r->dest_dsa_dns_name));
+               }
+               NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
+               NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dest_dsa_dns_name, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t), CH_DOS));
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
+{
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
+       ndr->depth++;
+       ndr_print_ptr(ndr, "naming_context", r->naming_context);
+       ndr->depth++;
+       ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
+       ndr->depth--;
+       ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
+       ndr->depth++;
+       ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
+       ndr->depth--;
+       ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
+       ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
+       ndr->depth--;
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
+               switch (level) {
+                       case 1: {
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
+                       break; }
+
+                       default:
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               switch (level) {
+                       case 1:
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
+                       break;
+
+                       default:
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
+{
+       int level;
+       int32_t _level;
+       level = ndr_pull_get_switch_value(ndr, r);
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
+               if (_level != level) {
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
+               }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
+               switch (level) {
+                       case 1: {
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
+                       break; }
+
+                       default:
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               switch (level) {
+                       case 1:
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
+                       break;
+
+                       default:
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
+{
+       int level;
+       level = ndr_print_get_switch_value(ndr, r);
+       ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
+       switch (level) {
+               case 1:
+                       ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
+               break;
+
+               default:
+                       ndr_print_bad_level(ndr, name, level);
+       }
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               if (r->naming_context == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_ref_ptr(ndr));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
+               NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               if (r->source_dsa_address) {
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
+{
+       uint32_t _ptr_naming_context;
+       TALLOC_CTX *_mem_save_naming_context_0;
+       uint32_t _ptr_source_dsa_address;
+       TALLOC_CTX *_mem_save_source_dsa_address_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
+               if (_ptr_naming_context) {
+                       NDR_PULL_ALLOC(ndr, r->naming_context);
+               } else {
+                       r->naming_context = NULL;
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
+               if (_ptr_source_dsa_address) {
+                       NDR_PULL_ALLOC(ndr, r->source_dsa_address);
+               } else {
+                       r->source_dsa_address = NULL;
+               }
+               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
+               NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
+               if (r->source_dsa_address) {
+                       _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
+                       if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
+{
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
+       ndr->depth++;
+       ndr_print_ptr(ndr, "naming_context", r->naming_context);
+       ndr->depth++;
+       ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
+       ndr->depth--;
+       ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
+       ndr->depth++;
+       if (r->source_dsa_address) {
+               ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
+       }
+       ndr->depth--;
+       ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
+       ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
+       ndr->depth--;
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               if (r->naming_context == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_ref_ptr(ndr));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
+               NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               if (r->source_dsa_dn) {
+                       NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
+               }
+               if (r->transport_dn) {
+                       NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
+               }
+               if (r->source_dsa_address) {
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
+{
+       uint32_t _ptr_naming_context;
+       TALLOC_CTX *_mem_save_naming_context_0;
+       uint32_t _ptr_source_dsa_dn;
+       TALLOC_CTX *_mem_save_source_dsa_dn_0;
+       uint32_t _ptr_transport_dn;
+       TALLOC_CTX *_mem_save_transport_dn_0;
+       uint32_t _ptr_source_dsa_address;
+       TALLOC_CTX *_mem_save_source_dsa_address_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
+               if (_ptr_naming_context) {
+                       NDR_PULL_ALLOC(ndr, r->naming_context);
+               } else {
+                       r->naming_context = NULL;
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
+               if (_ptr_source_dsa_dn) {
+                       NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
+               } else {
+                       r->source_dsa_dn = NULL;
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
+               if (_ptr_transport_dn) {
+                       NDR_PULL_ALLOC(ndr, r->transport_dn);
+               } else {
+                       r->transport_dn = NULL;
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
+               if (_ptr_source_dsa_address) {
+                       NDR_PULL_ALLOC(ndr, r->source_dsa_address);
+               } else {
+                       r->source_dsa_address = NULL;
+               }
+               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
+               NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
+               if (r->source_dsa_dn) {
+                       _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
+                       NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
+               }
+               if (r->transport_dn) {
+                       _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
+                       NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
+               }
+               if (r->source_dsa_address) {
+                       _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
+                       if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
+{
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
+       ndr->depth++;
+       ndr_print_ptr(ndr, "naming_context", r->naming_context);
+       ndr->depth++;
+       ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
+       ndr->depth--;
+       ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
+       ndr->depth++;
+       if (r->source_dsa_dn) {
+               ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
+       }
+       ndr->depth--;
+       ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
+       ndr->depth++;
+       if (r->transport_dn) {
+               ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
+       }
+       ndr->depth--;
+       ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
+       ndr->depth++;
+       if (r->source_dsa_address) {
+               ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
+       }
+       ndr->depth--;
+       ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
+       ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
+       ndr->depth--;
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
+               switch (level) {
+                       case 1: {
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
+                       break; }
+
+                       case 2: {
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
+                       break; }
+
+                       default:
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               switch (level) {
+                       case 1:
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
+                       break;
+
+                       case 2:
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
+                       break;
+
+                       default:
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
+{
+       int level;
+       int32_t _level;
+       level = ndr_pull_get_switch_value(ndr, r);
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
+               if (_level != level) {
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
+               }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
+               switch (level) {
+                       case 1: {
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
+                       break; }
+
+                       case 2: {
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
+                       break; }
+
+                       default:
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               switch (level) {
+                       case 1:
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
+                       break;
+
+                       case 2:
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
+                       break;
+
+                       default:
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
+{
+       int level;
+       level = ndr_print_get_switch_value(ndr, r);
+       ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
+       switch (level) {
+               case 1:
+                       ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
+               break;
+
+               case 2:
+                       ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
+               break;
+
+               default:
+                       ndr_print_bad_level(ndr, name, level);
+       }
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               if (r->naming_context == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_ref_ptr(ndr));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
+               NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               if (r->source_dsa_address) {
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
+{
+       uint32_t _ptr_naming_context;
+       TALLOC_CTX *_mem_save_naming_context_0;
+       uint32_t _ptr_source_dsa_address;
+       TALLOC_CTX *_mem_save_source_dsa_address_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
+               if (_ptr_naming_context) {
+                       NDR_PULL_ALLOC(ndr, r->naming_context);
+               } else {
+                       r->naming_context = NULL;
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
+               if (_ptr_source_dsa_address) {
+                       NDR_PULL_ALLOC(ndr, r->source_dsa_address);
+               } else {
+                       r->source_dsa_address = NULL;
+               }
+               NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
+               if (r->source_dsa_address) {
+                       _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
+                       if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
+{
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
+       ndr->depth++;
+       ndr_print_ptr(ndr, "naming_context", r->naming_context);
+       ndr->depth++;
+       ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
+       ndr->depth--;
+       ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
+       ndr->depth++;
+       if (r->source_dsa_address) {
+               ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
+       }
+       ndr->depth--;
+       ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
+       ndr->depth--;
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
+               switch (level) {
+                       case 1: {
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
+                       break; }
+
+                       default:
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               switch (level) {
+                       case 1:
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
+                       break;
+
+                       default:
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
+{
+       int level;
+       int32_t _level;
+       level = ndr_pull_get_switch_value(ndr, r);
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
+               if (_level != level) {
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
+               }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
+               switch (level) {
+                       case 1: {
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
+                       break; }
+
+                       default:
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               switch (level) {
+                       case 1:
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
+                       break;
+
+                       default:
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
+{
+       int level;
+       level = ndr_print_get_switch_value(ndr, r);
+       ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
+       switch (level) {
+               case 1:
+                       ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
+               break;
+
+               default:
+                       ndr_print_bad_level(ndr, name, level);
+       }
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               if (r->naming_context == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_ref_ptr(ndr));
+               NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
+               NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
+               if (r->source_dra_address) {
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dra_address, ndr_charset_length(r->source_dra_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
+{
+       uint32_t _ptr_naming_context;
+       TALLOC_CTX *_mem_save_naming_context_0;
+       uint32_t _ptr_source_dra_address;
+       TALLOC_CTX *_mem_save_source_dra_address_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
                if (_ptr_naming_context) {
                        NDR_PULL_ALLOC(ndr, r->naming_context);
                } else {
                        r->naming_context = NULL;
                }
-               NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
-               if (_ptr_dest_dsa_dns_name) {
-                       NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
+               NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
+               if (_ptr_source_dra_address) {
+                       NDR_PULL_ALLOC(ndr, r->source_dra_address);
                } else {
-                       r->dest_dsa_dns_name = NULL;
+                       r->source_dra_address = NULL;
                }
-               NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
-               NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
+               NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
                NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
-               NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
-               NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
-               if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
-                       return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dest_dsa_dns_name), ndr_get_array_length(ndr, &r->dest_dsa_dns_name));
+               if (r->source_dra_address) {
+                       _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
+                       if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dra_address), ndr_get_array_length(ndr, &r->source_dra_address));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dra_address, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
                }
-               NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
-               NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dest_dsa_dns_name, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t), CH_DOS));
        }
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
 {
-       ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
        ndr->depth++;
        ndr_print_ptr(ndr, "naming_context", r->naming_context);
        ndr->depth++;
        ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
        ndr->depth--;
-       ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
+       ndr_print_GUID(ndr, "source_dra", &r->source_dra);
+       ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
        ndr->depth++;
-       ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
+       if (r->source_dra_address) {
+               ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
+       }
        ndr->depth--;
-       ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
-       ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
+       ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
+       ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
+       ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
+       ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
        ndr->depth--;
 }
 
-static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
 {
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
-                               NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
                int level = ndr_push_get_switch_value(ndr, r);
                switch (level) {
                        case 1:
-                               NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
+                               NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
 }
 
-static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
 {
        int level;
        int32_t _level;
@@ -3632,38 +4634,39 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
-                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
                switch (level) {
                        case 1:
-                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
+                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
 {
        int level;
        level = ndr_print_get_switch_value(ndr, r);
-       ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
+       ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
        switch (level) {
                case 1:
-                       ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
+                       ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
                break;
 
                default:
@@ -3671,85 +4674,16 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr
        }
 }
 
-static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
-{
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
-       return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
-{
-       uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
-       *r = v;
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
-{
-       ndr_print_uint32(ndr, name, r);
-       ndr->depth++;
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
-       ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
-{
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
-       return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
-{
-       uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
-       *r = v;
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
-{
-       ndr_print_uint32(ndr, name, r);
-       ndr->depth++;
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_DELETE_WRITEABLE", DRSUAPI_DS_REPLICA_DELETE_WRITEABLE, r);
-       ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
-{
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
-       return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
-{
-       uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
-       *r = v;
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
-{
-       ndr_print_uint32(ndr, name, r);
-       ndr->depth++;
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION, r);
-       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE", DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE, r);
-       ndr->depth--;
-}
-
 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -3776,17 +4710,18 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *
        uint32_t cntr_group_attrs_1;
        uint32_t cntr_sids_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info_array) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
                        for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
                        }
@@ -3797,13 +4732,13 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *
                        }
                }
                if (r->group_attrs) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
                        for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
                                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
                        }
                }
                if (r->sids) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
                        for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
                        }
@@ -3834,14 +4769,14 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *
        TALLOC_CTX *_mem_save_sids_1;
        TALLOC_CTX *_mem_save_sids_2;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
-               if (r->num_memberships < 0 || r->num_memberships > 10000) {
+               if (r->num_memberships > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
-               if (r->num_sids < 0 || r->num_sids > 10000) {
+               if (r->num_sids > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
@@ -3862,6 +4797,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *
                } else {
                        r->sids = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info_array) {
@@ -4015,13 +4951,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4032,7 +4969,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *n
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4046,15 +4983,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4064,7 +5002,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *n
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4089,16 +5027,17 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_pu
 {
        uint32_t cntr_info_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
                NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info_array) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
                        }
@@ -4125,7 +5064,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pu
        uint32_t _ptr_domain;
        TALLOC_CTX *_mem_save_domain_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
                if (r->count < 1 || r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
@@ -4144,6 +5083,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pu
                } else {
                        r->domain = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info_array) {
@@ -4227,13 +5167,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4244,7 +5185,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_pus
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4258,15 +5199,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pul
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4276,7 +5218,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pul
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4300,15 +5242,16 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, c
 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
                }
        }
@@ -4320,11 +5263,11 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_p
        uint32_t _ptr_data;
        TALLOC_CTX *_mem_save_data_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
-               if (r->length < 0 || r->length > 0x00A00000) {
+               if (r->length > 0x00A00000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
@@ -4333,6 +5276,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_p
                } else {
                        r->data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -4371,13 +5315,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4388,7 +5333,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pu
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4402,15 +5347,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4420,7 +5366,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pu
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4456,14 +5402,15 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data1) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
                }
                if (r->data2) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
                }
        }
@@ -4479,11 +5426,11 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
-               if (r->length1 < 0 || r->length1 > 0x00A00000) {
+               if (r->length1 > 0x00A00000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
-               if (r->length2 < 0 || r->length2 > 0x00A00000) {
+               if (r->length2 > 0x00A00000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
@@ -4505,6 +5452,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull
                } else {
                        r->data2 = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data1) {
@@ -4566,13 +5514,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4583,7 +5532,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4597,15 +5546,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 8));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4615,7 +5565,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4638,14 +5588,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, con
 
 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -4669,14 +5619,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *
 
 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -4697,14 +5647,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *n
 
 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -4732,14 +5682,15 @@ _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *
 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->str) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -4751,13 +5702,14 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int
        uint32_t _ptr_str;
        TALLOC_CTX *_mem_save_str_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
                if (_ptr_str) {
                        NDR_PULL_ALLOC(ndr, r->str);
                } else {
                        r->str = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->str) {
@@ -4793,7 +5745,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, i
 {
        uint32_t cntr_names_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
                NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
@@ -4801,10 +5753,11 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
                        }
@@ -4823,7 +5776,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, i
        TALLOC_CTX *_mem_save_names_0;
        TALLOC_CTX *_mem_save_names_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
                NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
@@ -4839,6 +5792,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, i
                } else {
                        r->names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->names) {
@@ -4898,13 +5852,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4915,7 +5870,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, in
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4929,15 +5884,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -4947,7 +5903,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, in
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4971,22 +5927,23 @@ _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char
 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dns_domain_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_domain_name, ndr_charset_length(r->dns_domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->result_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -5000,7 +5957,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int
        uint32_t _ptr_result_name;
        TALLOC_CTX *_mem_save_result_name_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
                if (_ptr_dns_domain_name) {
@@ -5014,6 +5971,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int
                } else {
                        r->result_name = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dns_domain_name) {
@@ -5068,13 +6026,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int n
 {
        uint32_t cntr_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
                        }
@@ -5093,7 +6052,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int n
        TALLOC_CTX *_mem_save_array_0;
        TALLOC_CTX *_mem_save_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
                if (_ptr_array) {
@@ -5101,6 +6060,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int n
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -5155,13 +6115,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5174,7 +6135,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int nd
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5189,8 +6150,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                uint32_t _ptr_ctr1;
@@ -5203,7 +6165,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int nd
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5218,7 +6180,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int nd
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5246,14 +6208,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -5274,22 +6236,23 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_p
 {
        uint32_t cntr_spn_names_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->spn_names) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
                        }
@@ -5310,7 +6273,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_p
        TALLOC_CTX *_mem_save_spn_names_0;
        TALLOC_CTX *_mem_save_spn_names_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
@@ -5320,7 +6283,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_p
                        r->object_dn = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 10000) {
+               if (r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
@@ -5329,6 +6292,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_p
                } else {
                        r->spn_names = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -5403,13 +6367,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5420,7 +6385,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_pu
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5434,15 +6399,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5452,7 +6418,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pu
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5478,6 +6444,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5489,6 +6456,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5508,13 +6476,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5524,7 +6493,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_pus
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5538,15 +6507,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pul
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5555,7 +6525,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pul
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5579,22 +6549,23 @@ _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, c
 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->domain_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -5608,7 +6579,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pu
        uint32_t _ptr_domain_dn;
        TALLOC_CTX *_mem_save_domain_dn_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
                if (_ptr_server_dn) {
                        NDR_PULL_ALLOC(ndr, r->server_dn);
@@ -5622,6 +6593,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pu
                        r->domain_dn = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->server_dn) {
@@ -5677,13 +6649,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5694,7 +6667,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_pus
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5708,15 +6681,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pul
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5726,7 +6700,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pul
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5752,6 +6726,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5763,6 +6738,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pul
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -5782,13 +6758,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5798,7 +6775,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5812,15 +6789,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5829,7 +6807,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5853,15 +6831,16 @@ _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, co
 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -5873,7 +6852,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *n
        uint32_t _ptr_domain_name;
        TALLOC_CTX *_mem_save_domain_name_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
                if (_ptr_domain_name) {
                        NDR_PULL_ALLOC(ndr, r->domain_name);
@@ -5881,6 +6860,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *n
                        r->domain_name = NULL;
                }
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->domain_name) {
@@ -5918,13 +6898,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *nd
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5935,7 +6916,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *nd
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5949,15 +6930,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *nd
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -5967,7 +6949,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *nd
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5991,7 +6973,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const
 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
@@ -5999,36 +6981,37 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->dns_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->site_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->computer_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->server_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -6048,7 +7031,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int
        uint32_t _ptr_server_dn;
        TALLOC_CTX *_mem_save_server_dn_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
                if (_ptr_netbios_name) {
                        NDR_PULL_ALLOC(ndr, r->netbios_name);
@@ -6081,6 +7064,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -6190,13 +7174,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr,
 {
        uint32_t cntr_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
                        }
@@ -6215,9 +7200,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr,
        TALLOC_CTX *_mem_save_array_0;
        TALLOC_CTX *_mem_save_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 10000) {
+               if (r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
@@ -6226,6 +7211,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -6278,7 +7264,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const cha
 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
@@ -6293,48 +7279,49 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->dns_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->site_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->site_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->computer_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->server_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->ntds_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -6358,7 +7345,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int
        uint32_t _ptr_ntds_dn;
        TALLOC_CTX *_mem_save_ntds_dn_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
                if (_ptr_netbios_name) {
                        NDR_PULL_ALLOC(ndr, r->netbios_name);
@@ -6408,6 +7395,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -6558,13 +7546,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr,
 {
        uint32_t cntr_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
                        }
@@ -6583,9 +7572,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr,
        TALLOC_CTX *_mem_save_array_0;
        TALLOC_CTX *_mem_save_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 10000) {
+               if (r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
@@ -6594,6 +7583,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -6646,7 +7636,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const cha
 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
@@ -6662,48 +7652,49 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->dns_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->site_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->site_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->computer_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->server_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->ntds_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -6727,7 +7718,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int
        uint32_t _ptr_ntds_dn;
        TALLOC_CTX *_mem_save_ntds_dn_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
                if (_ptr_netbios_name) {
                        NDR_PULL_ALLOC(ndr, r->netbios_name);
@@ -6778,6 +7769,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->netbios_name) {
@@ -6929,13 +7921,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr,
 {
        uint32_t cntr_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
                        }
@@ -6954,9 +7947,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr,
        TALLOC_CTX *_mem_save_array_0;
        TALLOC_CTX *_mem_save_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 10000) {
+               if (r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
@@ -6965,6 +7958,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr,
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7017,7 +8011,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const cha
 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                {
                        uint32_t _flags_save_ipv4address = ndr->flags;
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
@@ -7030,12 +8024,13 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *n
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client_account) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -7047,7 +8042,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *n
        uint32_t _ptr_client_account;
        TALLOC_CTX *_mem_save_client_account_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                {
                        uint32_t _flags_save_ipv4address = ndr->flags;
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
@@ -7065,6 +8060,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *n
                } else {
                        r->client_account = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->client_account) {
@@ -7106,13 +8102,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push
 {
        uint32_t cntr_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
                        }
@@ -7131,9 +8128,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull
        TALLOC_CTX *_mem_save_array_0;
        TALLOC_CTX *_mem_save_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 10000) {
+               if (r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
@@ -7142,6 +8139,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull
                } else {
                        r->array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->array) {
@@ -7196,6 +8194,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DC_INFO_CTR_1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -7214,7 +8213,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, i
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -7237,7 +8236,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, i
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -7251,8 +8250,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, i
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DC_INFO_CTR_1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
@@ -7271,7 +8271,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, i
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -7293,7 +8293,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, i
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -7329,9 +8329,10 @@ _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char
 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next_object) {
@@ -7347,7 +8348,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_p
        uint32_t _ptr_next_object;
        TALLOC_CTX *_mem_save_next_object_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
                if (_ptr_next_object) {
                        NDR_PULL_ALLOC(ndr, r->next_object);
@@ -7355,6 +8356,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_p
                        r->next_object = NULL;
                }
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next_object) {
@@ -7371,8 +8373,9 @@ _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_p
 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
@@ -7383,8 +8386,9 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *nd
 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
@@ -7405,13 +8409,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -7422,7 +8427,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -7436,15 +8441,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -7454,7 +8460,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -7483,6 +8489,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7497,6 +8504,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -7517,13 +8525,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, cons
 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
                }
        }
@@ -7535,9 +8544,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_
        uint32_t _ptr_data;
        TALLOC_CTX *_mem_save_data_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
-               if (r->size < 0 || r->size > 10485760) {
+               if (r->size > 10485760) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
@@ -7546,6 +8555,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_
                } else {
                        r->data = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->data) {
@@ -7580,11 +8590,12 @@ _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr
 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
                NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
@@ -7595,11 +8606,12 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push
 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
                NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
@@ -7621,9 +8633,10 @@ _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, con
 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next) {
@@ -7639,7 +8652,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pu
        uint32_t _ptr_next;
        TALLOC_CTX *_mem_save_next_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
                if (_ptr_next) {
                        NDR_PULL_ALLOC(ndr, r->next);
@@ -7647,6 +8660,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pu
                        r->next = NULL;
                }
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->next) {
@@ -7677,10 +8691,11 @@ _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr,
 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -7696,7 +8711,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *
        uint32_t _ptr_id;
        TALLOC_CTX *_mem_save_id_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
                if (_ptr_id) {
                        NDR_PULL_ALLOC(ndr, r->id);
@@ -7705,6 +8720,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *
                }
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -7738,6 +8754,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
@@ -7760,7 +8777,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *n
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -7783,7 +8800,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *n
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -7797,8 +8814,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
@@ -7821,7 +8839,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *n
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -7843,7 +8861,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *n
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -7883,10 +8901,11 @@ _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const
 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -7902,7 +8921,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr,
        uint32_t _ptr_info;
        TALLOC_CTX *_mem_save_info_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
@@ -7911,6 +8930,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr,
                } else {
                        r->info = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -7945,13 +8965,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr,
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -7962,7 +8983,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr,
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -7976,15 +8997,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr,
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -7994,7 +9016,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr,
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -8021,6 +9043,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -8034,6 +9057,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
                NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
@@ -8054,19 +9078,20 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, i
 {
        uint32_t cntr_objects_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
                NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
                }
                if (r->objects) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
                        }
@@ -8087,7 +9112,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, i
        TALLOC_CTX *_mem_save_objects_0;
        TALLOC_CTX *_mem_save_objects_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
                if (_ptr_id) {
                        NDR_PULL_ALLOC(ndr, r->id);
@@ -8097,7 +9122,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 10000) {
+               if (r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
@@ -8106,6 +9131,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, i
                } else {
                        r->objects = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -8173,12 +9199,13 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, i
 {
        uint32_t cntr_objects_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -8189,7 +9216,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, i
                        NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
                }
                if (r->objects) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                        for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
                        }
@@ -8212,7 +9239,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, i
        TALLOC_CTX *_mem_save_objects_0;
        TALLOC_CTX *_mem_save_objects_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
                if (_ptr_id) {
                        NDR_PULL_ALLOC(ndr, r->id);
@@ -8227,7 +9254,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, i
                        r->error = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 10000) {
+               if (r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
@@ -8236,6 +9263,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, i
                } else {
                        r->objects = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->id) {
@@ -8317,6 +9345,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
@@ -8327,7 +9356,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, in
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -8342,7 +9371,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, in
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -8356,8 +9385,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 2: {
                                NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
@@ -8368,38 +9398,171 @@ static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, in
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               switch (level) {
+                       case 2:
+                               NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
+                       break;
+
+                       case 3:
+                               NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
+                       break;
+
+                       default:
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
+{
+       int level;
+       level = ndr_print_get_switch_value(ndr, r);
+       ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
+       switch (level) {
+               case 2:
+                       ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
+               break;
+
+               case 3:
+                       ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
+               break;
+
+               default:
+                       ndr_print_bad_level(ndr, name, level);
+       }
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
+{
+       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
+{
+       ndr_print_uint32(ndr, name, r);
+       ndr->depth++;
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
+       ndr->depth--;
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
+               NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
+               NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
+{
+       ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
+       ndr->depth++;
+       ndr_print_uint32(ndr, "taskID", r->taskID);
+       ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
+       ndr->depth--;
+}
+
+static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 4));
+               switch (level) {
+                       case 1: {
+                               NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
+                       break; }
+
+                       default:
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               int level = ndr_push_get_switch_value(ndr, r);
+               switch (level) {
+                       case 1:
+                       break;
+
+                       default:
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
+{
+       int level;
+       uint32_t _level;
+       level = ndr_pull_get_switch_value(ndr, r);
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
+               if (_level != level) {
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
+               }
+               NDR_CHECK(ndr_pull_union_align(ndr, 4));
+               switch (level) {
+                       case 1: {
+                               NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
+                       break; }
+
+                       default:
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
                switch (level) {
-                       case 2:
-                               NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
-                       break;
-
-                       case 3:
-                               NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
+                       case 1:
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
+_PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
 {
        int level;
        level = ndr_print_get_switch_value(ndr, r);
-       ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
+       ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
        switch (level) {
-               case 2:
-                       ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
-               break;
-
-               case 3:
-                       ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
+               case 1:
+                       ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
                break;
 
                default:
@@ -8409,14 +9572,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char
 
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -8434,14 +9597,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, con
 
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -8473,16 +9636,17 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const c
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -8494,7 +9658,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pu
        uint32_t _ptr_object_dn;
        TALLOC_CTX *_mem_save_object_dn_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
                if (_ptr_object_dn) {
@@ -8503,6 +9667,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pu
                        r->object_dn = NULL;
                }
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -8539,7 +9704,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr,
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
@@ -8547,24 +9712,25 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pu
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->string1) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->string2) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -8580,7 +9746,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pu
        uint32_t _ptr_string2;
        TALLOC_CTX *_mem_save_string2_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
                if (_ptr_object_dn) {
@@ -8603,6 +9769,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pu
                        r->string2 = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->object_dn) {
@@ -8679,6 +9846,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_GET_INFO: {
                                NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -8689,7 +9857,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_pus
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -8704,7 +9872,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_pus
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -8718,8 +9886,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pul
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_GET_INFO: {
                                NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
@@ -8730,7 +9899,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pul
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -8744,7 +9913,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pul
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -8789,30 +9958,31 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *nd
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->naming_context_dn, ndr_charset_length(r->naming_context_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->source_dsa_obj_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_obj_dn, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->source_dsa_address) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->transport_obj_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->transport_obj_dn, ndr_charset_length(r->transport_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -8867,6 +10037,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->naming_context_dn) {
@@ -8968,13 +10139,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -9003,6 +10175,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -9039,13 +10212,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *nd
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9071,6 +10245,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *nd
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -9107,12 +10282,13 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -9136,6 +10312,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -9176,13 +10353,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pus
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -9211,6 +10389,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pul
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -9246,18 +10425,19 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, c
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dsa_obj_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dsa_obj_dn, ndr_charset_length(r->dsa_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -9269,7 +10449,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull
        uint32_t _ptr_dsa_obj_dn;
        TALLOC_CTX *_mem_save_dsa_obj_dn_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
                if (_ptr_dsa_obj_dn) {
                        NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
@@ -9280,6 +10460,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->dsa_obj_dn) {
@@ -9319,13 +10500,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -9341,7 +10523,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_
        TALLOC_CTX *_mem_save_array_0;
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
                NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
@@ -9354,6 +10536,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -9388,14 +10571,14 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr
 
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
 {
-       NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
 {
        uint16_t v;
-       NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -9414,192 +10597,39 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const cha
        ndr_print_enum(ndr, name, "ENUM", val, r);
 }
 
-static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
-{
-       if (ndr_flags & NDR_SCALARS) {
-               int level = ndr_push_get_switch_value(ndr, r);
-               NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
-               switch (level) {
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
-                               NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
-                       break; }
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
-                               NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
-                       break; }
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
-                               NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
-                       break; }
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
-                               NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
-                       break; }
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
-                               NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
-                       break; }
-
-                       default: {
-                               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
-                       break; }
-
-               }
-       }
-       if (ndr_flags & NDR_BUFFERS) {
-               int level = ndr_push_get_switch_value(ndr, r);
-               switch (level) {
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
-                       break;
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
-                       break;
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
-                       break;
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
-                       break;
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
-                       break;
-
-                       default:
-                       break;
-
-               }
-       }
-       return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
-{
-       int level;
-       uint16_t _level;
-       level = ndr_pull_get_switch_value(ndr, r);
-       if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
-               if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
-               }
-               switch (level) {
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
-                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
-                       break; }
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
-                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
-                       break; }
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
-                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
-                       break; }
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
-                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
-                       break; }
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
-                               NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
-                       break; }
-
-                       default: {
-                               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
-                       break; }
-
-               }
-       }
-       if (ndr_flags & NDR_BUFFERS) {
-               switch (level) {
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
-                       break;
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
-                       break;
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
-                       break;
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
-                       break;
-
-                       case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
-                       break;
-
-                       default:
-                       break;
-
-               }
-       }
-       return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
-{
-       int level;
-       level = ndr_print_get_switch_value(ndr, r);
-       ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
-       switch (level) {
-               case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
-                       ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
-               break;
-
-               case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
-                       ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
-               break;
-
-               case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
-                       ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
-               break;
-
-               case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
-                       ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
-               break;
-
-               case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
-                       ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
-               break;
-
-               default:
-                       ndr_print_uint32(ndr, "unknown", r->unknown);
-               break;
-
-       }
-}
-
 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
                NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
-               NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
-               NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->nc_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->remote_dsa_obj_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote_dsa_obj_dn, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->remote_dsa_address) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote_dsa_address, ndr_charset_length(r->remote_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -9615,13 +10645,12 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int
        uint32_t _ptr_remote_dsa_address;
        TALLOC_CTX *_mem_save_remote_dsa_address_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
                NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
-               NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
-               NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
+               NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
                if (_ptr_nc_dn) {
                        NDR_PULL_ALLOC(ndr, r->nc_dn);
@@ -9642,6 +10671,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int
                }
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->nc_dn) {
@@ -9692,8 +10722,7 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *n
        ndr_print_uint32(ndr, "serial_num", r->serial_num);
        ndr_print_uint32(ndr, "priority", r->priority);
        ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
-       ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
-       ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
+       ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
        ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
        ndr->depth++;
        if (r->nc_dn) {
@@ -9721,13 +10750,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, i
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -9743,7 +10773,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, i
        TALLOC_CTX *_mem_save_array_0;
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
                NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
@@ -9756,6 +10786,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, i
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -9803,18 +10834,19 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_pu
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->object_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->binary) {
@@ -9860,6 +10892,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pu
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -9933,13 +10966,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -9968,6 +11002,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10004,13 +11039,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *n
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10036,6 +11072,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *n
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10070,12 +11107,13 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr,
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->source_dsa_obj_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_obj_dn, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -10097,6 +11135,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr,
                } else {
                        r->source_dsa_obj_dn = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->source_dsa_obj_dn) {
@@ -10135,13 +11174,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *n
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -10170,6 +11210,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *n
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10213,18 +11254,19 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->originating_dsa_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->originating_dsa_dn, ndr_charset_length(r->originating_dsa_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -10256,6 +11298,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull
                } else {
                        r->originating_dsa_dn = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -10314,13 +11357,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pu
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -10349,6 +11393,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pu
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10397,27 +11442,28 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_p
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->object_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->binary) {
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
                }
                if (r->originating_dsa_dn) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->originating_dsa_dn, ndr_charset_length(r->originating_dsa_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -10468,6 +11514,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_p
                } else {
                        r->originating_dsa_dn = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->attribute_name) {
@@ -10559,13 +11606,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct nd
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -10594,6 +11642,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct nd
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10642,6 +11691,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push
                        ndr->flags = _flags_save_ipv4address;
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10664,6 +11714,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull
                        ndr->flags = _flags_save_ipv4address;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10688,13 +11739,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_pu
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10709,7 +11761,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pu
                NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 10000) {
+               if (r->count > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
@@ -10723,6 +11775,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pu
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -10761,12 +11814,13 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->str1) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -10792,6 +11846,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->str1) {
@@ -10834,13 +11889,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, i
 {
        uint32_t cntr_array_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_align(ndr, 8));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
                        NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
@@ -10858,7 +11914,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
                NDR_CHECK(ndr_pull_align(ndr, 8));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
-               if (r->count < 0 || r->count > 256) {
+               if (r->count > 256) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
@@ -10872,6 +11928,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, i
                if (r->array) {
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
        }
        if (ndr_flags & NDR_BUFFERS) {
                _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
@@ -10909,6 +11966,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
@@ -10971,7 +12029,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, in
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -11068,7 +12126,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, in
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -11097,8 +12155,9 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, in
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
                                uint32_t _ptr_neighbours;
@@ -11251,7 +12310,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, in
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -11392,7 +12451,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, in
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -11549,13 +12608,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -11566,7 +12626,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -11580,15 +12640,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -11598,7 +12659,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -11623,13 +12684,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_p
 {
        uint32_t cntr_req_array_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->req_array) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
                        for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
                        }
@@ -11651,7 +12713,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_p
        TALLOC_CTX *_mem_save_req_array_1;
        TALLOC_CTX *_mem_save_req_array_2;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
                if (r->num_req < 1 || r->num_req > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
@@ -11662,6 +12724,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_p
                } else {
                        r->req_array = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->req_array) {
@@ -11731,13 +12794,14 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -11748,7 +12812,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_pu
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -11762,15 +12826,16 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pu
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -11780,7 +12845,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pu
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -11807,6 +12872,7 @@ static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, i
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11819,6 +12885,7 @@ static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, i
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -11838,14 +12905,15 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *
 {
        uint32_t cntr_info_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
                        for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
                                NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
                        }
@@ -11861,9 +12929,9 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *
        TALLOC_CTX *_mem_save_info_0;
        TALLOC_CTX *_mem_save_info_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
-               if (r->num_info < 0 || r->num_info > 10000) {
+               if (r->num_info > 10000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
@@ -11873,6 +12941,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *
                        r->info = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->info) {
@@ -11925,13 +12994,14 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *n
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -11942,7 +13012,7 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *n
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -11956,15 +13026,16 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *n
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -11974,7 +13045,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *n
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -11999,29 +13070,30 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_pu
 {
        uint32_t cntr_site_to_1;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->site_from) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->site_to) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
                        for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
                        }
                        for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
                                if (r->site_to[cntr_site_to_1]) {
-                                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
-                                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
+                                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
+                                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
                                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_to[cntr_site_to_1], ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16), sizeof(uint16_t), CH_UTF16));
                                }
                        }
@@ -12040,7 +13112,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pu
        TALLOC_CTX *_mem_save_site_to_1;
        TALLOC_CTX *_mem_save_site_to_2;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
                if (_ptr_site_from) {
                        NDR_PULL_ALLOC(ndr, r->site_from);
@@ -12058,6 +13130,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pu
                        r->site_to = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->site_from) {
@@ -12152,13 +13225,14 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_pus
        if (ndr_flags & NDR_SCALARS) {
                int level = ndr_push_get_switch_value(ndr, r);
                NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
+               NDR_CHECK(ndr_push_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -12169,7 +13243,7 @@ static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_pus
                        break;
 
                        default:
-                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -12183,15 +13257,16 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pul
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
                if (_level != level) {
-                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
+                       return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
                }
+               NDR_CHECK(ndr_pull_union_align(ndr, 5));
                switch (level) {
                        case 1: {
                                NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
                        break; }
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        if (ndr_flags & NDR_BUFFERS) {
@@ -12201,7 +13276,7 @@ static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pul
                        break;
 
                        default:
-                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+                               return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
                }
        }
        return NDR_ERR_SUCCESS;
@@ -12681,9 +13756,16 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const
        ndr->depth--;
 }
 
-static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_ADD(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_ADD *r)
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
 {
        if (flags & NDR_IN) {
+               if (r->in.bind_handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
+               NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
+               NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
@@ -12691,9 +13773,20 @@ static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_ADD(struct ndr_push *ndr, int
        return NDR_ERR_SUCCESS;
 }
 
-static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_ADD(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_ADD *r)
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
 {
+       TALLOC_CTX *_mem_save_bind_handle_0;
        if (flags & NDR_IN) {
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.bind_handle);
+               }
+               _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
+               NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
@@ -12701,20 +13794,27 @@ static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_ADD(struct ndr_pull *ndr, int
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_DRSUAPI_REPLICA_ADD(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_ADD *r)
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
 {
-       ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_ADD");
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
        ndr->depth++;
        if (flags & NDR_SET_VALUES) {
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
        }
        if (flags & NDR_IN) {
-               ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_ADD");
+               ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
+               ndr->depth++;
+               ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
                ndr->depth++;
+               ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
+               ndr->depth--;
+               ndr_print_int32(ndr, "level", r->in.level);
+               ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
+               ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
-               ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_ADD");
+               ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
                ndr->depth++;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -12722,9 +13822,16 @@ _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_ADD(struct ndr_print *ndr, const char *n
        ndr->depth--;
 }
 
-static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_DEL(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_DEL *r)
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
 {
        if (flags & NDR_IN) {
+               if (r->in.bind_handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
+               NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
+               NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
@@ -12732,9 +13839,20 @@ static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_DEL(struct ndr_push *ndr, int
        return NDR_ERR_SUCCESS;
 }
 
-static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_DEL(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_DEL *r)
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
 {
+       TALLOC_CTX *_mem_save_bind_handle_0;
        if (flags & NDR_IN) {
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.bind_handle);
+               }
+               _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
+               NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
@@ -12742,20 +13860,27 @@ static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_DEL(struct ndr_pull *ndr, int
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_DRSUAPI_REPLICA_DEL(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_DEL *r)
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
 {
-       ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_DEL");
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
        ndr->depth++;
        if (flags & NDR_SET_VALUES) {
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
        }
        if (flags & NDR_IN) {
-               ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_DEL");
+               ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
+               ndr->depth++;
+               ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
                ndr->depth++;
+               ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
+               ndr->depth--;
+               ndr_print_int32(ndr, "level", r->in.level);
+               ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
+               ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
-               ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_DEL");
+               ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
                ndr->depth++;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -12763,9 +13888,16 @@ _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_DEL(struct ndr_print *ndr, const char *n
        ndr->depth--;
 }
 
-static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_MODIFY(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_MODIFY *r)
+static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
 {
        if (flags & NDR_IN) {
+               if (r->in.bind_handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
+               NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
+               NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
+               NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
@@ -12773,9 +13905,20 @@ static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_MODIFY(struct ndr_push *ndr, i
        return NDR_ERR_SUCCESS;
 }
 
-static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_MODIFY(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_MODIFY *r)
+static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
 {
+       TALLOC_CTX *_mem_save_bind_handle_0;
        if (flags & NDR_IN) {
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.bind_handle);
+               }
+               _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
+               NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
+               NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
@@ -12783,20 +13926,27 @@ static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_MODIFY(struct ndr_pull *ndr, i
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_DRSUAPI_REPLICA_MODIFY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_MODIFY *r)
+_PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
 {
-       ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_MODIFY");
+       ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
        ndr->depth++;
        if (flags & NDR_SET_VALUES) {
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
        }
        if (flags & NDR_IN) {
-               ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_MODIFY");
+               ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
+               ndr->depth++;
+               ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
                ndr->depth++;
+               ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
+               ndr->depth--;
+               ndr_print_int32(ndr, "level", r->in.level);
+               ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
+               ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
-               ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_MODIFY");
+               ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
                ndr->depth++;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -13767,9 +14917,19 @@ _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *na
        ndr->depth--;
 }
 
-static enum ndr_err_code ndr_push_DRSUAPI_EXECUTE_KCC(struct ndr_push *ndr, int flags, const struct DRSUAPI_EXECUTE_KCC *r)
+static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
 {
        if (flags & NDR_IN) {
+               if (r->in.bind_handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
+               if (r->in.req == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
+               NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
@@ -13777,9 +14937,27 @@ static enum ndr_err_code ndr_push_DRSUAPI_EXECUTE_KCC(struct ndr_push *ndr, int
        return NDR_ERR_SUCCESS;
 }
 
-static enum ndr_err_code ndr_pull_DRSUAPI_EXECUTE_KCC(struct ndr_pull *ndr, int flags, struct DRSUAPI_EXECUTE_KCC *r)
+static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
 {
+       TALLOC_CTX *_mem_save_bind_handle_0;
+       TALLOC_CTX *_mem_save_req_0;
        if (flags & NDR_IN) {
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.bind_handle);
+               }
+               _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.req);
+               }
+               _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
+               NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
@@ -13787,20 +14965,30 @@ static enum ndr_err_code ndr_pull_DRSUAPI_EXECUTE_KCC(struct ndr_pull *ndr, int
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_DRSUAPI_EXECUTE_KCC(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_EXECUTE_KCC *r)
+_PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
 {
-       ndr_print_struct(ndr, name, "DRSUAPI_EXECUTE_KCC");
+       ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
        ndr->depth++;
        if (flags & NDR_SET_VALUES) {
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
        }
        if (flags & NDR_IN) {
-               ndr_print_struct(ndr, "in", "DRSUAPI_EXECUTE_KCC");
+               ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
+               ndr->depth++;
+               ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
+               ndr->depth--;
+               ndr_print_uint32(ndr, "level", r->in.level);
+               ndr_print_ptr(ndr, "req", r->in.req);
                ndr->depth++;
+               ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
+               ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
+               ndr->depth--;
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
-               ndr_print_struct(ndr, "out", "DRSUAPI_EXECUTE_KCC");
+               ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
                ndr->depth++;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -14333,27 +15521,27 @@ static const struct ndr_interface_call drsuapi_calls[] = {
                false,
        },
        {
-               "DRSUAPI_REPLICA_ADD",
-               sizeof(struct DRSUAPI_REPLICA_ADD),
-               (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_ADD,
-               (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_ADD,
-               (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_ADD,
+               "drsuapi_DsReplicaAdd",
+               sizeof(struct drsuapi_DsReplicaAdd),
+               (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
+               (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
+               (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
                false,
        },
        {
-               "DRSUAPI_REPLICA_DEL",
-               sizeof(struct DRSUAPI_REPLICA_DEL),
-               (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_DEL,
-               (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_DEL,
-               (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_DEL,
+               "drsuapi_DsReplicaDel",
+               sizeof(struct drsuapi_DsReplicaDel),
+               (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
+               (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
+               (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
                false,
        },
        {
-               "DRSUAPI_REPLICA_MODIFY",
-               sizeof(struct DRSUAPI_REPLICA_MODIFY),
-               (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_MODIFY,
-               (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_MODIFY,
-               (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_MODIFY,
+               "drsuapi_DsReplicaMod",
+               sizeof(struct drsuapi_DsReplicaMod),
+               (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
+               (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
+               (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
                false,
        },
        {
@@ -14437,11 +15625,11 @@ static const struct ndr_interface_call drsuapi_calls[] = {
                false,
        },
        {
-               "DRSUAPI_EXECUTE_KCC",
-               sizeof(struct DRSUAPI_EXECUTE_KCC),
-               (ndr_push_flags_fn_t) ndr_push_DRSUAPI_EXECUTE_KCC,
-               (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_EXECUTE_KCC,
-               (ndr_print_function_t) ndr_print_DRSUAPI_EXECUTE_KCC,
+               "drsuapi_DsExecuteKCC",
+               sizeof(struct drsuapi_DsExecuteKCC),
+               (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
+               (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
+               (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
                false,
        },
        {