new internal layout

18 files changed, 1340 insertions, 1462 deletions

diff --git a/tests/19-param-OK.asn1.-P b/tests/19-param-OK.asn1.-P
index 0b1b0d56..61038126 100644
--- a/tests/19-param-OK.asn1.-P
+++ b/tests/19-param-OK.asn1.-P
@@ -66,7 +66,7 @@ memb_signature_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 
 /*** <<< STAT-DEFS [Certificate] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_toBeSigned[] = {
+static asn_TYPE_member_t asn_MBR_toBeSigned_2[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct toBeSigned, version),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -89,24 +89,24 @@ static asn_TYPE_member_t asn_MBR_toBeSigned[] = {
 		.name = "issuer"
 		},
 };
-static ber_tlv_tag_t asn_DEF_toBeSigned_tags[] = {
+static ber_tlv_tag_t asn_DEF_toBeSigned_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_toBeSigned_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_toBeSigned_2_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* version at 21 */
     { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 1, 0, 0 }, /* signature at 22 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, 0, 0 } /* issuer at 24 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_toBeSigned_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_toBeSigned_2_specs = {
 	sizeof(struct toBeSigned),
 	offsetof(struct toBeSigned, _asn_ctx),
-	asn_DEF_toBeSigned_tag2el,
+	asn_MAP_toBeSigned_2_tag2el,
 	3,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_toBeSigned = {
+asn_TYPE_descriptor_t asn_DEF_toBeSigned_2 = {
 	"toBeSigned",
 	"toBeSigned",
 	SEQUENCE_free,
@@ -117,22 +117,22 @@ asn_TYPE_descriptor_t asn_DEF_toBeSigned = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_toBeSigned_tags,
-	sizeof(asn_DEF_toBeSigned_tags)
-		/sizeof(asn_DEF_toBeSigned_tags[0]), /* 1 */
-	asn_DEF_toBeSigned_tags,	/* Same as above */
-	sizeof(asn_DEF_toBeSigned_tags)
-		/sizeof(asn_DEF_toBeSigned_tags[0]), /* 1 */
-	asn_MBR_toBeSigned,
+	asn_DEF_toBeSigned_2_tags,
+	sizeof(asn_DEF_toBeSigned_2_tags)
+		/sizeof(asn_DEF_toBeSigned_2_tags[0]), /* 1 */
+	asn_DEF_toBeSigned_2_tags,	/* Same as above */
+	sizeof(asn_DEF_toBeSigned_2_tags)
+		/sizeof(asn_DEF_toBeSigned_2_tags[0]), /* 1 */
+	asn_MBR_toBeSigned_2,
 	3,	/* Elements count */
-	&asn_DEF_toBeSigned_specs	/* Additional specs */
+	&asn_SPC_toBeSigned_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_Certificate[] = {
+static asn_TYPE_member_t asn_MBR_Certificate_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Certificate, toBeSigned),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_toBeSigned,
+		.type = (void *)&asn_DEF_toBeSigned_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "toBeSigned"
 		},
@@ -151,18 +151,18 @@ static asn_TYPE_member_t asn_MBR_Certificate[] = {
 		.name = "signature"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Certificate_tags[] = {
+static ber_tlv_tag_t asn_DEF_Certificate_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Certificate_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Certificate_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 2, 0, 0 }, /* signature at 17 */
     { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 1, 0, 0 }, /* algorithm at 16 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* toBeSigned at 21 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_Certificate_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Certificate_1_specs = {
 	sizeof(struct Certificate),
 	offsetof(struct Certificate, _asn_ctx),
-	asn_DEF_Certificate_tag2el,
+	asn_MAP_Certificate_1_tag2el,
 	3,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -178,15 +178,15 @@ asn_TYPE_descriptor_t asn_DEF_Certificate = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Certificate_tags,
-	sizeof(asn_DEF_Certificate_tags)
-		/sizeof(asn_DEF_Certificate_tags[0]), /* 1 */
-	asn_DEF_Certificate_tags,	/* Same as above */
-	sizeof(asn_DEF_Certificate_tags)
-		/sizeof(asn_DEF_Certificate_tags[0]), /* 1 */
-	asn_MBR_Certificate,
+	asn_DEF_Certificate_1_tags,
+	sizeof(asn_DEF_Certificate_1_tags)
+		/sizeof(asn_DEF_Certificate_1_tags[0]), /* 1 */
+	asn_DEF_Certificate_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Certificate_1_tags)
+		/sizeof(asn_DEF_Certificate_1_tags[0]), /* 1 */
+	asn_MBR_Certificate_1,
 	3,	/* Elements count */
-	&asn_DEF_Certificate_specs	/* Additional specs */
+	&asn_SPC_Certificate_1_specs	/* Additional specs */
 };
 
 
@@ -212,7 +212,7 @@ typedef struct Name {
 
 /*** <<< STAT-DEFS [Name] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Name[] = {
+static asn_TYPE_member_t asn_MBR_Name_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
@@ -221,10 +221,10 @@ static asn_TYPE_member_t asn_MBR_Name[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Name_tags[] = {
+static ber_tlv_tag_t asn_DEF_Name_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_Name_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Name_1_specs = {
 	sizeof(struct Name),
 	offsetof(struct Name, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -240,15 +240,15 @@ asn_TYPE_descriptor_t asn_DEF_Name = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Name_tags,
-	sizeof(asn_DEF_Name_tags)
-		/sizeof(asn_DEF_Name_tags[0]), /* 1 */
-	asn_DEF_Name_tags,	/* Same as above */
-	sizeof(asn_DEF_Name_tags)
-		/sizeof(asn_DEF_Name_tags[0]), /* 1 */
-	asn_MBR_Name,
+	asn_DEF_Name_1_tags,
+	sizeof(asn_DEF_Name_1_tags)
+		/sizeof(asn_DEF_Name_1_tags[0]), /* 1 */
+	asn_DEF_Name_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Name_1_tags)
+		/sizeof(asn_DEF_Name_1_tags[0]), /* 1 */
+	asn_MBR_Name_1,
 	1,	/* Single element */
-	&asn_DEF_Name_specs	/* Additional specs */
+	&asn_SPC_Name_1_specs	/* Additional specs */
 };
 
 
@@ -303,7 +303,7 @@ static int check_permitted_alphabet_1(const void *sptr) {
 /*** <<< CODE [RelativeDistinguishedName] >>> ***/
 
 static int
-memb_IA5String_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_IA5String_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	const IA5String_t *st = (const IA5String_t *)sptr;
 	
@@ -329,19 +329,19 @@ memb_IA5String_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 
 /*** <<< STAT-DEFS [RelativeDistinguishedName] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_RelativeDistinguishedName[] = {
+static asn_TYPE_member_t asn_MBR_RelativeDistinguishedName_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)),
 		.tag_mode = 0,
 		.type = (void *)&asn_DEF_IA5String,
-		.memb_constraints = memb_IA5String_2_constraint,
+		.memb_constraints = memb_IA5String_1_constraint,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_RelativeDistinguishedName_tags[] = {
+static ber_tlv_tag_t asn_DEF_RelativeDistinguishedName_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_RelativeDistinguishedName_specs = {
+static asn_SET_OF_specifics_t asn_SPC_RelativeDistinguishedName_1_specs = {
 	sizeof(struct RelativeDistinguishedName),
 	offsetof(struct RelativeDistinguishedName, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -357,14 +357,14 @@ asn_TYPE_descriptor_t asn_DEF_RelativeDistinguishedName = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_RelativeDistinguishedName_tags,
-	sizeof(asn_DEF_RelativeDistinguishedName_tags)
-		/sizeof(asn_DEF_RelativeDistinguishedName_tags[0]), /* 1 */
-	asn_DEF_RelativeDistinguishedName_tags,	/* Same as above */
-	sizeof(asn_DEF_RelativeDistinguishedName_tags)
-		/sizeof(asn_DEF_RelativeDistinguishedName_tags[0]), /* 1 */
-	asn_MBR_RelativeDistinguishedName,
+	asn_DEF_RelativeDistinguishedName_1_tags,
+	sizeof(asn_DEF_RelativeDistinguishedName_1_tags)
+		/sizeof(asn_DEF_RelativeDistinguishedName_1_tags[0]), /* 1 */
+	asn_DEF_RelativeDistinguishedName_1_tags,	/* Same as above */
+	sizeof(asn_DEF_RelativeDistinguishedName_1_tags)
+		/sizeof(asn_DEF_RelativeDistinguishedName_1_tags[0]), /* 1 */
+	asn_MBR_RelativeDistinguishedName_1,
 	1,	/* Single element */
-	&asn_DEF_RelativeDistinguishedName_specs	/* Additional specs */
+	&asn_SPC_RelativeDistinguishedName_1_specs	/* Additional specs */
 };
 
diff --git a/tests/30-set-OK.asn1.-P b/tests/30-set-OK.asn1.-P
index ecb5e29e..849e9a95 100644
--- a/tests/30-set-OK.asn1.-P
+++ b/tests/30-set-OK.asn1.-P
@@ -41,7 +41,7 @@ typedef struct T {
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T[] = {
+static asn_TYPE_member_t asn_MBR_T_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T, i),
 		.tag = (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -64,27 +64,27 @@ static asn_TYPE_member_t asn_MBR_T[] = {
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)), 1, 0, 0 }, /* s at 16 */
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 0, 0, 0 }, /* i at 15 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* b at 18 */
 };
-static uint8_t asn_DEF_T_mmap[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_T_1_mmap[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (1 << 6) | (0 << 5)
 };
-static asn_SET_specifics_t asn_DEF_T_specs = {
+static asn_SET_specifics_t asn_SPC_T_1_specs = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
 	offsetof(struct T, _presence_map),
-	asn_DEF_T_tag2el,
+	asn_MAP_T_1_tag2el,
 	3,	/* Count of tags in the map */
-	asn_DEF_T_tag2el,	/* Same as above */
+	asn_MAP_T_1_tag2el,	/* Same as above */
 	3,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_DEF_T_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_T_1_mmap	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_T = {
 	"T",
@@ -97,14 +97,14 @@ asn_TYPE_descriptor_t asn_DEF_T = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_tags,
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 1 */
-	asn_DEF_T_tags,	/* Same as above */
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 1 */
-	asn_MBR_T,
+	asn_DEF_T_1_tags,
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 1 */
+	asn_DEF_T_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 1 */
+	asn_MBR_T_1,
 	3,	/* Elements count */
-	&asn_DEF_T_specs	/* Additional specs */
+	&asn_SPC_T_1_specs	/* Additional specs */
 };
 
diff --git a/tests/31-set-of-OK.asn1.-P b/tests/31-set-of-OK.asn1.-P
index e9e8776c..2bd3b125 100644
--- a/tests/31-set-of-OK.asn1.-P
+++ b/tests/31-set-of-OK.asn1.-P
@@ -21,7 +21,7 @@ typedef struct Forest {
 
 /*** <<< STAT-DEFS [Forest] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Forest[] = {
+static asn_TYPE_member_t asn_MBR_Forest_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
@@ -30,10 +30,10 @@ static asn_TYPE_member_t asn_MBR_Forest[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Forest_tags[] = {
+static ber_tlv_tag_t asn_DEF_Forest_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_Forest_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Forest_1_specs = {
 	sizeof(struct Forest),
 	offsetof(struct Forest, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -49,15 +49,15 @@ asn_TYPE_descriptor_t asn_DEF_Forest = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Forest_tags,
-	sizeof(asn_DEF_Forest_tags)
-		/sizeof(asn_DEF_Forest_tags[0]), /* 1 */
-	asn_DEF_Forest_tags,	/* Same as above */
-	sizeof(asn_DEF_Forest_tags)
-		/sizeof(asn_DEF_Forest_tags[0]), /* 1 */
-	asn_MBR_Forest,
+	asn_DEF_Forest_1_tags,
+	sizeof(asn_DEF_Forest_1_tags)
+		/sizeof(asn_DEF_Forest_1_tags[0]), /* 1 */
+	asn_DEF_Forest_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Forest_1_tags)
+		/sizeof(asn_DEF_Forest_1_tags[0]), /* 1 */
+	asn_MBR_Forest_1,
 	1,	/* Single element */
-	&asn_DEF_Forest_specs	/* Additional specs */
+	&asn_SPC_Forest_1_specs	/* Additional specs */
 };
 
 
@@ -83,7 +83,7 @@ typedef struct Tree {
 
 /*** <<< STAT-DEFS [Tree] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Tree[] = {
+static asn_TYPE_member_t asn_MBR_Tree_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Tree, height),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -99,17 +99,17 @@ static asn_TYPE_member_t asn_MBR_Tree[] = {
 		.name = "width"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Tree_tags[] = {
+static ber_tlv_tag_t asn_DEF_Tree_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Tree_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Tree_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 1 }, /* height at 17 */
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, -1, 0 } /* width at 19 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_Tree_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Tree_1_specs = {
 	sizeof(struct Tree),
 	offsetof(struct Tree, _asn_ctx),
-	asn_DEF_Tree_tag2el,
+	asn_MAP_Tree_1_tag2el,
 	2,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -125,15 +125,15 @@ asn_TYPE_descriptor_t asn_DEF_Tree = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Tree_tags,
-	sizeof(asn_DEF_Tree_tags)
-		/sizeof(asn_DEF_Tree_tags[0]), /* 1 */
-	asn_DEF_Tree_tags,	/* Same as above */
-	sizeof(asn_DEF_Tree_tags)
-		/sizeof(asn_DEF_Tree_tags[0]), /* 1 */
-	asn_MBR_Tree,
+	asn_DEF_Tree_1_tags,
+	sizeof(asn_DEF_Tree_1_tags)
+		/sizeof(asn_DEF_Tree_1_tags[0]), /* 1 */
+	asn_DEF_Tree_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Tree_1_tags)
+		/sizeof(asn_DEF_Tree_1_tags[0]), /* 1 */
+	asn_MBR_Tree_1,
 	2,	/* Elements count */
-	&asn_DEF_Tree_specs	/* Additional specs */
+	&asn_SPC_Tree_1_specs	/* Additional specs */
 };
 
 
@@ -177,7 +177,7 @@ typedef struct Stuff {
 		asn_struct_ctx_t _asn_ctx;
 	} *trees;
 	struct anything {
-		A_SET_OF(struct anything_Member {
+		A_SET_OF(struct Member {
 			BIT_STRING_t	 cup_of_coffee;
 			/*
 			 * This type is extensible,
@@ -216,7 +216,7 @@ typedef struct Stuff {
 
 /*** <<< STAT-DEFS [Stuff] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_trees[] = {
+static asn_TYPE_member_t asn_MBR_trees_2[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
@@ -225,17 +225,17 @@ static asn_TYPE_member_t asn_MBR_trees[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_trees_tags[] = {
+static ber_tlv_tag_t asn_DEF_trees_2_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_trees_specs = {
+static asn_SET_OF_specifics_t asn_SPC_trees_2_specs = {
 	sizeof(struct trees),
 	offsetof(struct trees, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_trees = {
+asn_TYPE_descriptor_t asn_DEF_trees_2 = {
 	"trees",
 	"trees",
 	SET_OF_free,
@@ -246,19 +246,19 @@ asn_TYPE_descriptor_t asn_DEF_trees = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_trees_tags,
-	sizeof(asn_DEF_trees_tags)
-		/sizeof(asn_DEF_trees_tags[0]) - 1, /* 1 */
-	asn_DEF_trees_tags,	/* Same as above */
-	sizeof(asn_DEF_trees_tags)
-		/sizeof(asn_DEF_trees_tags[0]), /* 2 */
-	asn_MBR_trees,
+	asn_DEF_trees_2_tags,
+	sizeof(asn_DEF_trees_2_tags)
+		/sizeof(asn_DEF_trees_2_tags[0]) - 1, /* 1 */
+	asn_DEF_trees_2_tags,	/* Same as above */
+	sizeof(asn_DEF_trees_2_tags)
+		/sizeof(asn_DEF_trees_2_tags[0]), /* 2 */
+	asn_MBR_trees_2,
 	1,	/* Single element */
-	&asn_DEF_trees_specs	/* Additional specs */
+	&asn_SPC_trees_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_anything_Member[] = {
-	{ ATF_NOFLAGS, 0, offsetof(struct anything_Member, cup_of_coffee),
+static asn_TYPE_member_t asn_MBR_Member_4[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Member, cup_of_coffee),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)),
 		.tag_mode = 0,
 		.type = (void *)&asn_DEF_BIT_STRING,
@@ -266,22 +266,22 @@ static asn_TYPE_member_t asn_MBR_anything_Member[] = {
 		.name = "cup-of-coffee"
 		},
 };
-static ber_tlv_tag_t asn_DEF_anything_Member_tags[] = {
+static ber_tlv_tag_t asn_DEF_Member_4_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_anything_Member_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Member_4_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 0, 0, 0 } /* cup-of-coffee at 32 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_anything_Member_specs = {
-	sizeof(struct anything_Member),
-	offsetof(struct anything_Member, _asn_ctx),
-	asn_DEF_anything_Member_tag2el,
+static asn_SEQUENCE_specifics_t asn_SPC_Member_4_specs = {
+	sizeof(struct Member),
+	offsetof(struct Member, _asn_ctx),
+	asn_MAP_Member_4_tag2el,
 	1,	/* Count of tags in the map */
 	0,	/* Start extensions */
 	2	/* Stop extensions */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_anything_Member = {
+asn_TYPE_descriptor_t asn_DEF_Member_4 = {
 	"",
 	"",
 	SEQUENCE_free,
@@ -292,37 +292,37 @@ asn_TYPE_descriptor_t asn_DEF_anything_Member = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_anything_Member_tags,
-	sizeof(asn_DEF_anything_Member_tags)
-		/sizeof(asn_DEF_anything_Member_tags[0]), /* 1 */
-	asn_DEF_anything_Member_tags,	/* Same as above */
-	sizeof(asn_DEF_anything_Member_tags)
-		/sizeof(asn_DEF_anything_Member_tags[0]), /* 1 */
-	asn_MBR_anything_Member,
+	asn_DEF_Member_4_tags,
+	sizeof(asn_DEF_Member_4_tags)
+		/sizeof(asn_DEF_Member_4_tags[0]), /* 1 */
+	asn_DEF_Member_4_tags,	/* Same as above */
+	sizeof(asn_DEF_Member_4_tags)
+		/sizeof(asn_DEF_Member_4_tags[0]), /* 1 */
+	asn_MBR_Member_4,
 	1,	/* Elements count */
-	&asn_DEF_anything_Member_specs	/* Additional specs */
+	&asn_SPC_Member_4_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_anything[] = {
+static asn_TYPE_member_t asn_MBR_anything_3[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_anything_Member,
+		.type = (void *)&asn_DEF_Member_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_anything_tags[] = {
+static ber_tlv_tag_t asn_DEF_anything_3_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_anything_specs = {
+static asn_SET_OF_specifics_t asn_SPC_anything_3_specs = {
 	sizeof(struct anything),
 	offsetof(struct anything, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_anything = {
+asn_TYPE_descriptor_t asn_DEF_anything_3 = {
 	"anything",
 	"anything",
 	SET_OF_free,
@@ -333,18 +333,18 @@ asn_TYPE_descriptor_t asn_DEF_anything = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_anything_tags,
-	sizeof(asn_DEF_anything_tags)
-		/sizeof(asn_DEF_anything_tags[0]) - 1, /* 1 */
-	asn_DEF_anything_tags,	/* Same as above */
-	sizeof(asn_DEF_anything_tags)
-		/sizeof(asn_DEF_anything_tags[0]), /* 2 */
-	asn_MBR_anything,
+	asn_DEF_anything_3_tags,
+	sizeof(asn_DEF_anything_3_tags)
+		/sizeof(asn_DEF_anything_3_tags[0]) - 1, /* 1 */
+	asn_DEF_anything_3_tags,	/* Same as above */
+	sizeof(asn_DEF_anything_3_tags)
+		/sizeof(asn_DEF_anything_3_tags[0]), /* 2 */
+	asn_MBR_anything_3,
 	1,	/* Single element */
-	&asn_DEF_anything_specs	/* Additional specs */
+	&asn_SPC_anything_3_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_other[] = {
+static asn_TYPE_member_t asn_MBR_other_5[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct other, choice.a),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -360,21 +360,21 @@ static asn_TYPE_member_t asn_MBR_other[] = {
 		.name = "b"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_other_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_other_5_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 26 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 1, 0, 0 } /* b at 28 */
 };
-static asn_CHOICE_specifics_t asn_DEF_other_specs = {
+static asn_CHOICE_specifics_t asn_SPC_other_5_specs = {
 	sizeof(struct other),
 	offsetof(struct other, _asn_ctx),
 	offsetof(struct other, present),
 	sizeof(((struct other *)0)->present),
-	asn_DEF_other_tag2el,
+	asn_MAP_other_5_tag2el,
 	2,	/* Count of tags in the map */
 	0	/* Whether extensible */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_other = {
+asn_TYPE_descriptor_t asn_DEF_other_5 = {
 	"other",
 	"other",
 	CHOICE_free,
@@ -389,61 +389,61 @@ asn_TYPE_descriptor_t asn_DEF_other = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_other,
+	asn_MBR_other_5,
 	2,	/* Elements count */
-	&asn_DEF_other_specs	/* Additional specs */
+	&asn_SPC_other_5_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_Stuff[] = {
+static asn_TYPE_member_t asn_MBR_Stuff_1[] = {
 	{ ATF_POINTER, 3, offsetof(struct Stuff, trees),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
-		.type = (void *)&asn_DEF_trees,
+		.type = (void *)&asn_DEF_trees_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "trees"
 		},
 	{ ATF_POINTER, 2, offsetof(struct Stuff, anything),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
-		.type = (void *)&asn_DEF_anything,
+		.type = (void *)&asn_DEF_anything_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "anything"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Stuff, other),
 		.tag = -1 /* Ambiguous tag (CHOICE?) */,
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_other,
+		.type = (void *)&asn_DEF_other_5,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "other"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Stuff_tags[] = {
+static ber_tlv_tag_t asn_DEF_Stuff_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Stuff_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Stuff_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 }, /* a at 26 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* trees at 23 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* anything at 34 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 } /* b at 28 */
 };
-static asn_TYPE_tag2member_t asn_DEF_Stuff_tag2el_cxer[] = {
+static asn_TYPE_tag2member_t asn_MAP_Stuff_1_tag2el_cxer[] = {
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* trees at 23 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* anything at 34 */
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 2, 0, 0 } /* a at 26 */
 };
-static uint8_t asn_DEF_Stuff_mmap[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Stuff_1_mmap[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(0 << 7) | (0 << 6) | (0 << 5)
 };
-static asn_SET_specifics_t asn_DEF_Stuff_specs = {
+static asn_SET_specifics_t asn_SPC_Stuff_1_specs = {
 	sizeof(struct Stuff),
 	offsetof(struct Stuff, _asn_ctx),
 	offsetof(struct Stuff, _presence_map),
-	asn_DEF_Stuff_tag2el,
+	asn_MAP_Stuff_1_tag2el,
 	4,	/* Count of tags in the map */
-	asn_DEF_Stuff_tag2el_cxer,
+	asn_MAP_Stuff_1_tag2el_cxer,
 	3,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_DEF_Stuff_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Stuff_1_mmap	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Stuff = {
 	"Stuff",
@@ -456,14 +456,14 @@ asn_TYPE_descriptor_t asn_DEF_Stuff = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Stuff_tags,
-	sizeof(asn_DEF_Stuff_tags)
-		/sizeof(asn_DEF_Stuff_tags[0]), /* 1 */
-	asn_DEF_Stuff_tags,	/* Same as above */
-	sizeof(asn_DEF_Stuff_tags)
-		/sizeof(asn_DEF_Stuff_tags[0]), /* 1 */
-	asn_MBR_Stuff,
+	asn_DEF_Stuff_1_tags,
+	sizeof(asn_DEF_Stuff_1_tags)
+		/sizeof(asn_DEF_Stuff_1_tags[0]), /* 1 */
+	asn_DEF_Stuff_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Stuff_1_tags)
+		/sizeof(asn_DEF_Stuff_1_tags[0]), /* 1 */
+	asn_MBR_Stuff_1,
 	3,	/* Elements count */
-	&asn_DEF_Stuff_specs	/* Additional specs */
+	&asn_SPC_Stuff_1_specs	/* Additional specs */
 };
 
diff --git a/tests/32-sequence-of-OK.asn1.-P b/tests/32-sequence-of-OK.asn1.-P
index 3c6ded26..1a579deb 100644
--- a/tests/32-sequence-of-OK.asn1.-P
+++ b/tests/32-sequence-of-OK.asn1.-P
@@ -21,7 +21,7 @@ typedef struct Programming {
 
 /*** <<< STAT-DEFS [Programming] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Programming[] = {
+static asn_TYPE_member_t asn_MBR_Programming_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -30,10 +30,10 @@ static asn_TYPE_member_t asn_MBR_Programming[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Programming_tags[] = {
+static ber_tlv_tag_t asn_DEF_Programming_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_Programming_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Programming_1_specs = {
 	sizeof(struct Programming),
 	offsetof(struct Programming, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -49,15 +49,15 @@ asn_TYPE_descriptor_t asn_DEF_Programming = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Programming_tags,
-	sizeof(asn_DEF_Programming_tags)
-		/sizeof(asn_DEF_Programming_tags[0]), /* 1 */
-	asn_DEF_Programming_tags,	/* Same as above */
-	sizeof(asn_DEF_Programming_tags)
-		/sizeof(asn_DEF_Programming_tags[0]), /* 1 */
-	asn_MBR_Programming,
+	asn_DEF_Programming_1_tags,
+	sizeof(asn_DEF_Programming_1_tags)
+		/sizeof(asn_DEF_Programming_1_tags[0]), /* 1 */
+	asn_DEF_Programming_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Programming_1_tags)
+		/sizeof(asn_DEF_Programming_1_tags[0]), /* 1 */
+	asn_MBR_Programming_1,
 	1,	/* Single element */
-	&asn_DEF_Programming_specs	/* Additional specs */
+	&asn_SPC_Programming_1_specs	/* Additional specs */
 };
 
 
@@ -83,7 +83,7 @@ typedef struct Fault {
 
 /*** <<< STAT-DEFS [Fault] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Fault[] = {
+static asn_TYPE_member_t asn_MBR_Fault_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
@@ -92,10 +92,10 @@ static asn_TYPE_member_t asn_MBR_Fault[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Fault_tags[] = {
+static ber_tlv_tag_t asn_DEF_Fault_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_Fault_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Fault_1_specs = {
 	sizeof(struct Fault),
 	offsetof(struct Fault, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -111,15 +111,15 @@ asn_TYPE_descriptor_t asn_DEF_Fault = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Fault_tags,
-	sizeof(asn_DEF_Fault_tags)
-		/sizeof(asn_DEF_Fault_tags[0]), /* 1 */
-	asn_DEF_Fault_tags,	/* Same as above */
-	sizeof(asn_DEF_Fault_tags)
-		/sizeof(asn_DEF_Fault_tags[0]), /* 1 */
-	asn_MBR_Fault,
+	asn_DEF_Fault_1_tags,
+	sizeof(asn_DEF_Fault_1_tags)
+		/sizeof(asn_DEF_Fault_1_tags[0]), /* 1 */
+	asn_DEF_Fault_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Fault_1_tags)
+		/sizeof(asn_DEF_Fault_1_tags[0]), /* 1 */
+	asn_MBR_Fault_1,
 	1,	/* Single element */
-	&asn_DEF_Fault_specs	/* Additional specs */
+	&asn_SPC_Fault_1_specs	/* Additional specs */
 };
 
 
@@ -146,15 +146,15 @@ typedef struct Error {
 
 /*** <<< STAT-DEFS [Error] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Error_tags[] = {
+static ber_tlv_tag_t asn_DEF_Error_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Error_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Error_1_tag2el[] = {
 };
-static asn_SEQUENCE_specifics_t asn_DEF_Error_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Error_1_specs = {
 	sizeof(struct Error),
 	offsetof(struct Error, _asn_ctx),
-	asn_DEF_Error_tag2el,
+	asn_MAP_Error_1_tag2el,
 	0,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -170,13 +170,13 @@ asn_TYPE_descriptor_t asn_DEF_Error = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Error_tags,
-	sizeof(asn_DEF_Error_tags)
-		/sizeof(asn_DEF_Error_tags[0]), /* 1 */
-	asn_DEF_Error_tags,	/* Same as above */
-	sizeof(asn_DEF_Error_tags)
-		/sizeof(asn_DEF_Error_tags[0]), /* 1 */
+	asn_DEF_Error_1_tags,
+	sizeof(asn_DEF_Error_1_tags)
+		/sizeof(asn_DEF_Error_1_tags[0]), /* 1 */
+	asn_DEF_Error_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Error_1_tags)
+		/sizeof(asn_DEF_Error_1_tags[0]), /* 1 */
 	0, 0,	/* No members */
-	&asn_DEF_Error_specs	/* Additional specs */
+	&asn_SPC_Error_1_specs	/* Additional specs */
 };
 
diff --git a/tests/39-sequence-of-OK.asn1.-P b/tests/39-sequence-of-OK.asn1.-P
index 68435f77..351e01ba 100644
--- a/tests/39-sequence-of-OK.asn1.-P
+++ b/tests/39-sequence-of-OK.asn1.-P
@@ -29,7 +29,7 @@ typedef struct T {
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_collection[] = {
+static asn_TYPE_member_t asn_MBR_collection_2[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
@@ -38,16 +38,16 @@ static asn_TYPE_member_t asn_MBR_collection[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_collection_tags[] = {
+static ber_tlv_tag_t asn_DEF_collection_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_collection_specs = {
+static asn_SET_OF_specifics_t asn_SPC_collection_2_specs = {
 	sizeof(struct collection),
 	offsetof(struct collection, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_collection = {
+asn_TYPE_descriptor_t asn_DEF_collection_2 = {
 	"collection",
 	"collection",
 	SEQUENCE_OF_free,
@@ -58,18 +58,18 @@ asn_TYPE_descriptor_t asn_DEF_collection = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_collection_tags,
-	sizeof(asn_DEF_collection_tags)
-		/sizeof(asn_DEF_collection_tags[0]), /* 1 */
-	asn_DEF_collection_tags,	/* Same as above */
-	sizeof(asn_DEF_collection_tags)
-		/sizeof(asn_DEF_collection_tags[0]), /* 1 */
-	asn_MBR_collection,
+	asn_DEF_collection_2_tags,
+	sizeof(asn_DEF_collection_2_tags)
+		/sizeof(asn_DEF_collection_2_tags[0]), /* 1 */
+	asn_DEF_collection_2_tags,	/* Same as above */
+	sizeof(asn_DEF_collection_2_tags)
+		/sizeof(asn_DEF_collection_2_tags[0]), /* 1 */
+	asn_MBR_collection_2,
 	1,	/* Single element */
-	&asn_DEF_collection_specs	/* Additional specs */
+	&asn_SPC_collection_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_T[] = {
+static asn_TYPE_member_t asn_MBR_T_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T, Int),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -80,22 +80,22 @@ static asn_TYPE_member_t asn_MBR_T[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T, collection),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_collection,
+		.type = (void *)&asn_DEF_collection_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "collection"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* int at 15 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 } /* collection at 17 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_T_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T_1_specs = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
-	asn_DEF_T_tag2el,
+	asn_MAP_T_1_tag2el,
 	2,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -111,15 +111,15 @@ asn_TYPE_descriptor_t asn_DEF_T = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_tags,
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 1 */
-	asn_DEF_T_tags,	/* Same as above */
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 1 */
-	asn_MBR_T,
+	asn_DEF_T_1_tags,
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 1 */
+	asn_DEF_T_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 1 */
+	asn_MBR_T_1,
 	2,	/* Elements count */
-	&asn_DEF_T_specs	/* Additional specs */
+	&asn_SPC_T_1_specs	/* Additional specs */
 };
 
 
@@ -146,7 +146,7 @@ typedef struct T2 {
 
 /*** <<< STAT-DEFS [T2] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T2[] = {
+static asn_TYPE_member_t asn_MBR_T2_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T2, flag),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
 		.tag_mode = 0,
@@ -162,17 +162,17 @@ static asn_TYPE_member_t asn_MBR_T2[] = {
 		.name = "str"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T2_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T2_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 0, 0, 0 }, /* flag at 20 */
     { (ASN_TAG_CLASS_UNIVERSAL | (12 << 2)), 1, 0, 0 } /* str at 21 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_T2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T2_1_specs = {
 	sizeof(struct T2),
 	offsetof(struct T2, _asn_ctx),
-	asn_DEF_T2_tag2el,
+	asn_MAP_T2_1_tag2el,
 	2,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -188,14 +188,14 @@ asn_TYPE_descriptor_t asn_DEF_T2 = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T2_tags,
-	sizeof(asn_DEF_T2_tags)
-		/sizeof(asn_DEF_T2_tags[0]), /* 1 */
-	asn_DEF_T2_tags,	/* Same as above */
-	sizeof(asn_DEF_T2_tags)
-		/sizeof(asn_DEF_T2_tags[0]), /* 1 */
-	asn_MBR_T2,
+	asn_DEF_T2_1_tags,
+	sizeof(asn_DEF_T2_1_tags)
+		/sizeof(asn_DEF_T2_1_tags[0]), /* 1 */
+	asn_DEF_T2_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T2_1_tags)
+		/sizeof(asn_DEF_T2_1_tags[0]), /* 1 */
+	asn_MBR_T2_1,
 	2,	/* Elements count */
-	&asn_DEF_T2_specs	/* Additional specs */
+	&asn_SPC_T2_1_specs	/* Additional specs */
 };
 
diff --git a/tests/42-real-life-OK.asn1.-PR b/tests/42-real-life-OK.asn1.-PR
index dda3bdb1..6394912e 100644
--- a/tests/42-real-life-OK.asn1.-PR
+++ b/tests/42-real-life-OK.asn1.-PR
@@ -65,7 +65,7 @@ memb_varsets_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 
 /*** <<< STAT-DEFS [LogLine] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_varsets[] = {
+static asn_TYPE_member_t asn_MBR_varsets_2[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
@@ -74,16 +74,16 @@ static asn_TYPE_member_t asn_MBR_varsets[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_varsets_tags[] = {
+static ber_tlv_tag_t asn_DEF_varsets_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_varsets_specs = {
+static asn_SET_OF_specifics_t asn_SPC_varsets_2_specs = {
 	sizeof(struct varsets),
 	offsetof(struct varsets, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_varsets = {
+asn_TYPE_descriptor_t asn_DEF_varsets_2 = {
 	"varsets",
 	"varsets",
 	SEQUENCE_OF_free,
@@ -94,18 +94,18 @@ asn_TYPE_descriptor_t asn_DEF_varsets = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_varsets_tags,
-	sizeof(asn_DEF_varsets_tags)
-		/sizeof(asn_DEF_varsets_tags[0]), /* 1 */
-	asn_DEF_varsets_tags,	/* Same as above */
-	sizeof(asn_DEF_varsets_tags)
-		/sizeof(asn_DEF_varsets_tags[0]), /* 1 */
-	asn_MBR_varsets,
+	asn_DEF_varsets_2_tags,
+	sizeof(asn_DEF_varsets_2_tags)
+		/sizeof(asn_DEF_varsets_2_tags[0]), /* 1 */
+	asn_DEF_varsets_2_tags,	/* Same as above */
+	sizeof(asn_DEF_varsets_2_tags)
+		/sizeof(asn_DEF_varsets_2_tags[0]), /* 1 */
+	asn_MBR_varsets_2,
 	1,	/* Single element */
-	&asn_DEF_varsets_specs	/* Additional specs */
+	&asn_SPC_varsets_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_LogLine[] = {
+static asn_TYPE_member_t asn_MBR_LogLine_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct LogLine, line_digest),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)),
 		.tag_mode = 0,
@@ -116,22 +116,22 @@ static asn_TYPE_member_t asn_MBR_LogLine[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct LogLine, varsets),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_varsets,
+		.type = (void *)&asn_DEF_varsets_2,
 		.memb_constraints = memb_varsets_1_constraint,
 		.name = "varsets"
 		},
 };
-static ber_tlv_tag_t asn_DEF_LogLine_tags[] = {
+static ber_tlv_tag_t asn_DEF_LogLine_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_LogLine_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_LogLine_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* varsets at 25 */
     { (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)), 0, 0, 0 } /* line-digest at 23 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_LogLine_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_LogLine_1_specs = {
 	sizeof(struct LogLine),
 	offsetof(struct LogLine, _asn_ctx),
-	asn_DEF_LogLine_tag2el,
+	asn_MAP_LogLine_1_tag2el,
 	2,	/* Count of tags in the map */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
@@ -147,15 +147,15 @@ asn_TYPE_descriptor_t asn_DEF_LogLine = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_LogLine_tags,
-	sizeof(asn_DEF_LogLine_tags)
-		/sizeof(asn_DEF_LogLine_tags[0]), /* 1 */
-	asn_DEF_LogLine_tags,	/* Same as above */
-	sizeof(asn_DEF_LogLine_tags)
-		/sizeof(asn_DEF_LogLine_tags[0]), /* 1 */
-	asn_MBR_LogLine,
+	asn_DEF_LogLine_1_tags,
+	sizeof(asn_DEF_LogLine_1_tags)
+		/sizeof(asn_DEF_LogLine_1_tags[0]), /* 1 */
+	asn_DEF_LogLine_1_tags,	/* Same as above */
+	sizeof(asn_DEF_LogLine_1_tags)
+		/sizeof(asn_DEF_LogLine_1_tags[0]), /* 1 */
+	asn_MBR_LogLine_1,
 	2,	/* Elements count */
-	&asn_DEF_LogLine_specs	/* Additional specs */
+	&asn_SPC_LogLine_1_specs	/* Additional specs */
 };
 
 
@@ -194,7 +194,7 @@ typedef struct VariablePartSet {
 /*** <<< CODE [VariablePartSet] >>> ***/
 
 static int
-memb_vparts_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_vparts_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	
 	if(!sptr) {
@@ -215,7 +215,7 @@ memb_vparts_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 
 /*** <<< STAT-DEFS [VariablePartSet] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_vparts[] = {
+static asn_TYPE_member_t asn_MBR_vparts_2[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = -1 /* Ambiguous tag (CHOICE?) */,
 		.tag_mode = 0,
@@ -224,16 +224,16 @@ static asn_TYPE_member_t asn_MBR_vparts[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_vparts_tags[] = {
+static ber_tlv_tag_t asn_DEF_vparts_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_vparts_specs = {
+static asn_SET_OF_specifics_t asn_SPC_vparts_2_specs = {
 	sizeof(struct vparts),
 	offsetof(struct vparts, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_vparts = {
+asn_TYPE_descriptor_t asn_DEF_vparts_2 = {
 	"vparts",
 	"vparts",
 	SEQUENCE_OF_free,
@@ -244,23 +244,23 @@ asn_TYPE_descriptor_t asn_DEF_vparts = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_vparts_tags,
-	sizeof(asn_DEF_vparts_tags)
-		/sizeof(asn_DEF_vparts_tags[0]), /* 1 */
-	asn_DEF_vparts_tags,	/* Same as above */
-	sizeof(asn_DEF_vparts_tags)
-		/sizeof(asn_DEF_vparts_tags[0]), /* 1 */
-	asn_MBR_vparts,
+	asn_DEF_vparts_2_tags,
+	sizeof(asn_DEF_vparts_2_tags)
+		/sizeof(asn_DEF_vparts_2_tags[0]), /* 1 */
+	asn_DEF_vparts_2_tags,	/* Same as above */
+	sizeof(asn_DEF_vparts_2_tags)
+		/sizeof(asn_DEF_vparts_2_tags[0]), /* 1 */
+	asn_MBR_vparts_2,
 	1,	/* Single element */
-	&asn_DEF_vparts_specs	/* Additional specs */
+	&asn_SPC_vparts_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_VariablePartSet[] = {
+static asn_TYPE_member_t asn_MBR_VariablePartSet_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct VariablePartSet, vparts),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_vparts,
-		.memb_constraints = memb_vparts_2_constraint,
+		.type = (void *)&asn_DEF_vparts_2,
+		.memb_constraints = memb_vparts_1_constraint,
 		.name = "vparts"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct VariablePartSet, resolution),
@@ -271,17 +271,17 @@ static asn_TYPE_member_t asn_MBR_VariablePartSet[] = {
 		.name = "resolution"
 		},
 };
-static ber_tlv_tag_t asn_DEF_VariablePartSet_tags[] = {
+static ber_tlv_tag_t asn_DEF_VariablePartSet_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_VariablePartSet_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_VariablePartSet_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* vparts at 33 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* resolution at 35 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_VariablePartSet_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_VariablePartSet_1_specs = {
 	sizeof(struct VariablePartSet),
 	offsetof(struct VariablePartSet, _asn_ctx),
-	asn_DEF_VariablePartSet_tag2el,
+	asn_MAP_VariablePartSet_1_tag2el,
 	2,	/* Count of tags in the map */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
@@ -297,15 +297,15 @@ asn_TYPE_descriptor_t asn_DEF_VariablePartSet = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_VariablePartSet_tags,
-	sizeof(asn_DEF_VariablePartSet_tags)
-		/sizeof(asn_DEF_VariablePartSet_tags[0]), /* 1 */
-	asn_DEF_VariablePartSet_tags,	/* Same as above */
-	sizeof(asn_DEF_VariablePartSet_tags)
-		/sizeof(asn_DEF_VariablePartSet_tags[0]), /* 1 */
-	asn_MBR_VariablePartSet,
+	asn_DEF_VariablePartSet_1_tags,
+	sizeof(asn_DEF_VariablePartSet_1_tags)
+		/sizeof(asn_DEF_VariablePartSet_1_tags[0]), /* 1 */
+	asn_DEF_VariablePartSet_1_tags,	/* Same as above */
+	sizeof(asn_DEF_VariablePartSet_1_tags)
+		/sizeof(asn_DEF_VariablePartSet_1_tags[0]), /* 1 */
+	asn_MBR_VariablePartSet_1,
 	2,	/* Elements count */
-	&asn_DEF_VariablePartSet_specs	/* Additional specs */
+	&asn_SPC_VariablePartSet_1_specs	/* Additional specs */
 };
 
 
@@ -363,7 +363,7 @@ typedef struct VariablePart {
 /*** <<< CODE [VariablePart] >>> ***/
 
 static int
-memb_vset_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_vset_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	size_t size;
 	
@@ -394,7 +394,7 @@ memb_vset_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 
 /*** <<< STAT-DEFS [VariablePart] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_vset[] = {
+static asn_TYPE_member_t asn_MBR_vset_2[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)),
 		.tag_mode = 0,
@@ -403,16 +403,16 @@ static asn_TYPE_member_t asn_MBR_vset[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_vset_tags[] = {
+static ber_tlv_tag_t asn_DEF_vset_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_vset_specs = {
+static asn_SET_OF_specifics_t asn_SPC_vset_2_specs = {
 	sizeof(struct vset),
 	offsetof(struct vset, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_vset = {
+asn_TYPE_descriptor_t asn_DEF_vset_2 = {
 	"vset",
 	"vset",
 	SET_OF_free,
@@ -423,18 +423,18 @@ asn_TYPE_descriptor_t asn_DEF_vset = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_vset_tags,
-	sizeof(asn_DEF_vset_tags)
-		/sizeof(asn_DEF_vset_tags[0]), /* 1 */
-	asn_DEF_vset_tags,	/* Same as above */
-	sizeof(asn_DEF_vset_tags)
-		/sizeof(asn_DEF_vset_tags[0]), /* 1 */
-	asn_MBR_vset,
+	asn_DEF_vset_2_tags,
+	sizeof(asn_DEF_vset_2_tags)
+		/sizeof(asn_DEF_vset_2_tags[0]), /* 1 */
+	asn_DEF_vset_2_tags,	/* Same as above */
+	sizeof(asn_DEF_vset_2_tags)
+		/sizeof(asn_DEF_vset_2_tags[0]), /* 1 */
+	asn_MBR_vset_2,
 	1,	/* Single element */
-	&asn_DEF_vset_specs	/* Additional specs */
+	&asn_SPC_vset_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_vrange[] = {
+static asn_TYPE_member_t asn_MBR_vrange_3[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct vrange, from),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)),
 		.tag_mode = 0,
@@ -450,23 +450,23 @@ static asn_TYPE_member_t asn_MBR_vrange[] = {
 		.name = "to"
 		},
 };
-static ber_tlv_tag_t asn_DEF_vrange_tags[] = {
+static ber_tlv_tag_t asn_DEF_vrange_3_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_vrange_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_vrange_3_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)), 0, 0, 1 }, /* from at 45 */
     { (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)), 1, -1, 0 } /* to at 46 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_vrange_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_vrange_3_specs = {
 	sizeof(struct vrange),
 	offsetof(struct vrange, _asn_ctx),
-	asn_DEF_vrange_tag2el,
+	asn_MAP_vrange_3_tag2el,
 	2,	/* Count of tags in the map */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_vrange = {
+asn_TYPE_descriptor_t asn_DEF_vrange_3 = {
 	"vrange",
 	"vrange",
 	SEQUENCE_free,
@@ -477,43 +477,43 @@ asn_TYPE_descriptor_t asn_DEF_vrange = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_vrange_tags,
-	sizeof(asn_DEF_vrange_tags)
-		/sizeof(asn_DEF_vrange_tags[0]), /* 1 */
-	asn_DEF_vrange_tags,	/* Same as above */
-	sizeof(asn_DEF_vrange_tags)
-		/sizeof(asn_DEF_vrange_tags[0]), /* 1 */
-	asn_MBR_vrange,
+	asn_DEF_vrange_3_tags,
+	sizeof(asn_DEF_vrange_3_tags)
+		/sizeof(asn_DEF_vrange_3_tags[0]), /* 1 */
+	asn_DEF_vrange_3_tags,	/* Same as above */
+	sizeof(asn_DEF_vrange_3_tags)
+		/sizeof(asn_DEF_vrange_3_tags[0]), /* 1 */
+	asn_MBR_vrange_3,
 	2,	/* Elements count */
-	&asn_DEF_vrange_specs	/* Additional specs */
+	&asn_SPC_vrange_3_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_VariablePart[] = {
+static asn_TYPE_member_t asn_MBR_VariablePart_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct VariablePart, choice.vset),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_vset,
-		.memb_constraints = memb_vset_3_constraint,
+		.type = (void *)&asn_DEF_vset_2,
+		.memb_constraints = memb_vset_1_constraint,
 		.name = "vset"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct VariablePart, choice.vrange),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_vrange,
+		.type = (void *)&asn_DEF_vrange_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "vrange"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_VariablePart_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_VariablePart_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* vrange at 45 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* vset at 42 */
 };
-static asn_CHOICE_specifics_t asn_DEF_VariablePart_specs = {
+static asn_CHOICE_specifics_t asn_SPC_VariablePart_1_specs = {
 	sizeof(struct VariablePart),
 	offsetof(struct VariablePart, _asn_ctx),
 	offsetof(struct VariablePart, present),
 	sizeof(((struct VariablePart *)0)->present),
-	asn_DEF_VariablePart_tag2el,
+	asn_MAP_VariablePart_1_tag2el,
 	2,	/* Count of tags in the map */
 	1	/* Whether extensible */
 };
@@ -532,9 +532,9 @@ asn_TYPE_descriptor_t asn_DEF_VariablePart = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_VariablePart,
+	asn_MBR_VariablePart_1,
 	2,	/* Elements count */
-	&asn_DEF_VariablePart_specs	/* Additional specs */
+	&asn_SPC_VariablePart_1_specs	/* Additional specs */
 };
 
 
@@ -591,12 +591,12 @@ typedef struct ActionItem {
 
 /*** <<< FUNC-DECLS [ActionItem] >>> ***/
 
-/* extern asn_TYPE_descriptor_t asn_DEF_accept_as;	// (Use -fall-defs-global to expose) */
+/* extern asn_TYPE_descriptor_t asn_DEF_accept_as_2;	// (Use -fall-defs-global to expose) */
 
 /*** <<< CODE [ActionItem] >>> ***/
 
 static int
-accept_as_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+accept_as_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	/* Replace with underlying type checker */
 	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
@@ -608,7 +608,7 @@ accept_as_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-accept_as_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+accept_as_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
 	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
 	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
@@ -621,97 +621,97 @@ accept_as_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 }
 
 static void
-accept_as_free(asn_TYPE_descriptor_t *td,
+accept_as_2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	accept_as_inherit_TYPE_descriptor(td);
+	accept_as_2_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 static int
-accept_as_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+accept_as_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	accept_as_inherit_TYPE_descriptor(td);
+	accept_as_2_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 static asn_dec_rval_t
-accept_as_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+accept_as_2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	accept_as_inherit_TYPE_descriptor(td);
+	accept_as_2_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
 static asn_enc_rval_t
-accept_as_encode_der(asn_TYPE_descriptor_t *td,
+accept_as_2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	accept_as_inherit_TYPE_descriptor(td);
+	accept_as_2_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 static asn_dec_rval_t
-accept_as_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+accept_as_2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	accept_as_inherit_TYPE_descriptor(td);
+	accept_as_2_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
 static asn_enc_rval_t
-accept_as_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+accept_as_2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	accept_as_inherit_TYPE_descriptor(td);
+	accept_as_2_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [ActionItem] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_accept_as_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_accept_as_2_value2enum[] = {
 	{ 0,	7,	"unknown" },
 	{ 1,	4,	"safe" },
 	{ 2,	6,	"unsafe" }
 	/* This list is extensible */
 };
-static unsigned int asn_MAP_accept_as_enum2value[] = {
+static unsigned int asn_MAP_accept_as_2_enum2value[] = {
 	1,	/* safe(1) */
 	0,	/* unknown(0) */
 	2	/* unsafe(2) */
 	/* This list is extensible */
 };
-static asn_INTEGER_specifics_t asn_DEF_accept_as_specs = {
-	asn_MAP_accept_as_value2enum,	/* "tag" => N; sorted by tag */
-	asn_MAP_accept_as_enum2value,	/* N => "tag"; sorted by N */
+static asn_INTEGER_specifics_t asn_SPC_accept_as_2_specs = {
+	asn_MAP_accept_as_2_value2enum,	/* "tag" => N; sorted by tag */
+	asn_MAP_accept_as_2_enum2value,	/* N => "tag"; sorted by N */
 	3,	/* Number of elements in the maps */
 	1,	/* Enumeration is extensible */
 	1	/* Strict enumeration */
 };
-static ber_tlv_tag_t asn_DEF_accept_as_tags[] = {
+static ber_tlv_tag_t asn_DEF_accept_as_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_accept_as = {
+asn_TYPE_descriptor_t asn_DEF_accept_as_2 = {
 	"accept-as",
 	"accept-as",
-	accept_as_free,
-	accept_as_print,
-	accept_as_constraint,
-	accept_as_decode_ber,
-	accept_as_encode_der,
-	accept_as_decode_xer,
-	accept_as_encode_xer,
+	accept_as_2_free,
+	accept_as_2_print,
+	accept_as_2_constraint,
+	accept_as_2_decode_ber,
+	accept_as_2_encode_der,
+	accept_as_2_decode_xer,
+	accept_as_2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_accept_as_tags,
-	sizeof(asn_DEF_accept_as_tags)
-		/sizeof(asn_DEF_accept_as_tags[0]), /* 1 */
-	asn_DEF_accept_as_tags,	/* Same as above */
-	sizeof(asn_DEF_accept_as_tags)
-		/sizeof(asn_DEF_accept_as_tags[0]), /* 1 */
+	asn_DEF_accept_as_2_tags,
+	sizeof(asn_DEF_accept_as_2_tags)
+		/sizeof(asn_DEF_accept_as_2_tags[0]), /* 1 */
+	asn_DEF_accept_as_2_tags,	/* Same as above */
+	sizeof(asn_DEF_accept_as_2_tags)
+		/sizeof(asn_DEF_accept_as_2_tags[0]), /* 1 */
 	0, 0,	/* Defined elsewhere */
-	&asn_DEF_accept_as_specs	/* Additional specs */
+	&asn_SPC_accept_as_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_email[] = {
+static asn_TYPE_member_t asn_MBR_email_4[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)),
 		.tag_mode = 0,
@@ -720,16 +720,16 @@ static asn_TYPE_member_t asn_MBR_email[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_email_tags[] = {
+static ber_tlv_tag_t asn_DEF_email_4_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_email_specs = {
+static asn_SET_OF_specifics_t asn_SPC_email_4_specs = {
 	sizeof(struct email),
 	offsetof(struct email, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_email = {
+asn_TYPE_descriptor_t asn_DEF_email_4 = {
 	"email",
 	"email",
 	SET_OF_free,
@@ -740,18 +740,18 @@ asn_TYPE_descriptor_t asn_DEF_email = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_email_tags,
-	sizeof(asn_DEF_email_tags)
-		/sizeof(asn_DEF_email_tags[0]), /* 1 */
-	asn_DEF_email_tags,	/* Same as above */
-	sizeof(asn_DEF_email_tags)
-		/sizeof(asn_DEF_email_tags[0]), /* 1 */
-	asn_MBR_email,
+	asn_DEF_email_4_tags,
+	sizeof(asn_DEF_email_4_tags)
+		/sizeof(asn_DEF_email_4_tags[0]), /* 1 */
+	asn_DEF_email_4_tags,	/* Same as above */
+	sizeof(asn_DEF_email_4_tags)
+		/sizeof(asn_DEF_email_4_tags[0]), /* 1 */
+	asn_MBR_email_4,
 	1,	/* Single element */
-	&asn_DEF_email_specs	/* Additional specs */
+	&asn_SPC_email_4_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_notify[] = {
+static asn_TYPE_member_t asn_MBR_notify_3[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct notify, critical),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
 		.tag_mode = 0,
@@ -762,28 +762,28 @@ static asn_TYPE_member_t asn_MBR_notify[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct notify, email),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_email,
+		.type = (void *)&asn_DEF_email_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "email"
 		},
 };
-static ber_tlv_tag_t asn_DEF_notify_tags[] = {
+static ber_tlv_tag_t asn_DEF_notify_3_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_notify_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_notify_3_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 0, 0, 0 }, /* critical at 61 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 1, 0, 0 } /* email at 62 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_notify_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_notify_3_specs = {
 	sizeof(struct notify),
 	offsetof(struct notify, _asn_ctx),
-	asn_DEF_notify_tag2el,
+	asn_MAP_notify_3_tag2el,
 	2,	/* Count of tags in the map */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_notify = {
+asn_TYPE_descriptor_t asn_DEF_notify_3 = {
 	"notify",
 	"notify",
 	SEQUENCE_free,
@@ -794,44 +794,44 @@ asn_TYPE_descriptor_t asn_DEF_notify = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_notify_tags,
-	sizeof(asn_DEF_notify_tags)
-		/sizeof(asn_DEF_notify_tags[0]), /* 1 */
-	asn_DEF_notify_tags,	/* Same as above */
-	sizeof(asn_DEF_notify_tags)
-		/sizeof(asn_DEF_notify_tags[0]), /* 1 */
-	asn_MBR_notify,
+	asn_DEF_notify_3_tags,
+	sizeof(asn_DEF_notify_3_tags)
+		/sizeof(asn_DEF_notify_3_tags[0]), /* 1 */
+	asn_DEF_notify_3_tags,	/* Same as above */
+	sizeof(asn_DEF_notify_3_tags)
+		/sizeof(asn_DEF_notify_3_tags[0]), /* 1 */
+	asn_MBR_notify_3,
 	2,	/* Elements count */
-	&asn_DEF_notify_specs	/* Additional specs */
+	&asn_SPC_notify_3_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_ActionItem[] = {
+static asn_TYPE_member_t asn_MBR_ActionItem_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct ActionItem, accept_as),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_accept_as,
+		.type = (void *)&asn_DEF_accept_as_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "accept-as"
 		},
 	{ ATF_POINTER, 1, offsetof(struct ActionItem, notify),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_notify,
+		.type = (void *)&asn_DEF_notify_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "notify"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ActionItem_tags[] = {
+static ber_tlv_tag_t asn_DEF_ActionItem_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_ActionItem_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ActionItem_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 0, 0, 0 }, /* accept-as at 55 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 } /* notify at 61 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_ActionItem_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_ActionItem_1_specs = {
 	sizeof(struct ActionItem),
 	offsetof(struct ActionItem, _asn_ctx),
-	asn_DEF_ActionItem_tag2el,
+	asn_MAP_ActionItem_1_tag2el,
 	2,	/* Count of tags in the map */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
@@ -847,14 +847,14 @@ asn_TYPE_descriptor_t asn_DEF_ActionItem = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ActionItem_tags,
-	sizeof(asn_DEF_ActionItem_tags)
-		/sizeof(asn_DEF_ActionItem_tags[0]), /* 1 */
-	asn_DEF_ActionItem_tags,	/* Same as above */
-	sizeof(asn_DEF_ActionItem_tags)
-		/sizeof(asn_DEF_ActionItem_tags[0]), /* 1 */
-	asn_MBR_ActionItem,
+	asn_DEF_ActionItem_1_tags,
+	sizeof(asn_DEF_ActionItem_1_tags)
+		/sizeof(asn_DEF_ActionItem_1_tags[0]), /* 1 */
+	asn_DEF_ActionItem_1_tags,	/* Same as above */
+	sizeof(asn_DEF_ActionItem_1_tags)
+		/sizeof(asn_DEF_ActionItem_1_tags[0]), /* 1 */
+	asn_MBR_ActionItem_1,
 	2,	/* Elements count */
-	&asn_DEF_ActionItem_specs	/* Additional specs */
+	&asn_SPC_ActionItem_1_specs	/* Additional specs */
 };
 
diff --git a/tests/43-recursion-OK.asn1.-P b/tests/43-recursion-OK.asn1.-P
index a5f86546..de356380 100644
--- a/tests/43-recursion-OK.asn1.-P
+++ b/tests/43-recursion-OK.asn1.-P
@@ -40,7 +40,7 @@ typedef struct Test_structure_1 {
 
 /*** <<< STAT-DEFS [Test-structure-1] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_t_member1[] = {
+static asn_TYPE_member_t asn_MBR_t_member1_2[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
@@ -49,16 +49,16 @@ static asn_TYPE_member_t asn_MBR_t_member1[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_t_member1_tags[] = {
+static ber_tlv_tag_t asn_DEF_t_member1_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_t_member1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_t_member1_2_specs = {
 	sizeof(struct t_member1),
 	offsetof(struct t_member1, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_t_member1 = {
+asn_TYPE_descriptor_t asn_DEF_t_member1_2 = {
 	"t-member1",
 	"t-member1",
 	SET_OF_free,
@@ -69,18 +69,18 @@ asn_TYPE_descriptor_t asn_DEF_t_member1 = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_t_member1_tags,
-	sizeof(asn_DEF_t_member1_tags)
-		/sizeof(asn_DEF_t_member1_tags[0]), /* 1 */
-	asn_DEF_t_member1_tags,	/* Same as above */
-	sizeof(asn_DEF_t_member1_tags)
-		/sizeof(asn_DEF_t_member1_tags[0]), /* 1 */
-	asn_MBR_t_member1,
+	asn_DEF_t_member1_2_tags,
+	sizeof(asn_DEF_t_member1_2_tags)
+		/sizeof(asn_DEF_t_member1_2_tags[0]), /* 1 */
+	asn_DEF_t_member1_2_tags,	/* Same as above */
+	sizeof(asn_DEF_t_member1_2_tags)
+		/sizeof(asn_DEF_t_member1_2_tags[0]), /* 1 */
+	asn_MBR_t_member1_2,
 	1,	/* Single element */
-	&asn_DEF_t_member1_specs	/* Additional specs */
+	&asn_SPC_t_member1_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_t_member2[] = {
+static asn_TYPE_member_t asn_MBR_t_member2_3[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
@@ -89,16 +89,16 @@ static asn_TYPE_member_t asn_MBR_t_member2[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_t_member2_tags[] = {
+static ber_tlv_tag_t asn_DEF_t_member2_3_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_t_member2_specs = {
+static asn_SET_OF_specifics_t asn_SPC_t_member2_3_specs = {
 	sizeof(struct t_member2),
 	offsetof(struct t_member2, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_t_member2 = {
+asn_TYPE_descriptor_t asn_DEF_t_member2_3 = {
 	"t-member2",
 	"t-member2",
 	SEQUENCE_OF_free,
@@ -109,29 +109,29 @@ asn_TYPE_descriptor_t asn_DEF_t_member2 = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_t_member2_tags,
-	sizeof(asn_DEF_t_member2_tags)
-		/sizeof(asn_DEF_t_member2_tags[0]), /* 1 */
-	asn_DEF_t_member2_tags,	/* Same as above */
-	sizeof(asn_DEF_t_member2_tags)
-		/sizeof(asn_DEF_t_member2_tags[0]), /* 1 */
-	asn_MBR_t_member2,
+	asn_DEF_t_member2_3_tags,
+	sizeof(asn_DEF_t_member2_3_tags)
+		/sizeof(asn_DEF_t_member2_3_tags[0]), /* 1 */
+	asn_DEF_t_member2_3_tags,	/* Same as above */
+	sizeof(asn_DEF_t_member2_3_tags)
+		/sizeof(asn_DEF_t_member2_3_tags[0]), /* 1 */
+	asn_MBR_t_member2_3,
 	1,	/* Single element */
-	&asn_DEF_t_member2_specs	/* Additional specs */
+	&asn_SPC_t_member2_3_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_Test_structure_1[] = {
+static asn_TYPE_member_t asn_MBR_Test_structure_1_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Test_structure_1, t_member1),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_t_member1,
+		.type = (void *)&asn_DEF_t_member1_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "t-member1"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Test_structure_1, t_member2),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_t_member2,
+		.type = (void *)&asn_DEF_t_member2_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "t-member2"
 		},
@@ -150,19 +150,19 @@ static asn_TYPE_member_t asn_MBR_Test_structure_1[] = {
 		.name = "t-member4"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Test_structure_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Test_structure_1_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Test_structure_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Test_structure_1_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 3, 0, 0 }, /* t-member4 at 19 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 1 }, /* t-member2 at 16 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 }, /* t-member3 at 17 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* t-member1 at 15 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_Test_structure_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Test_structure_1_1_specs = {
 	sizeof(struct Test_structure_1),
 	offsetof(struct Test_structure_1, _asn_ctx),
-	asn_DEF_Test_structure_1_tag2el,
+	asn_MAP_Test_structure_1_1_tag2el,
 	4,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -178,15 +178,15 @@ asn_TYPE_descriptor_t asn_DEF_Test_structure_1 = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Test_structure_1_tags,
-	sizeof(asn_DEF_Test_structure_1_tags)
-		/sizeof(asn_DEF_Test_structure_1_tags[0]), /* 1 */
-	asn_DEF_Test_structure_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Test_structure_1_tags)
-		/sizeof(asn_DEF_Test_structure_1_tags[0]), /* 1 */
-	asn_MBR_Test_structure_1,
+	asn_DEF_Test_structure_1_1_tags,
+	sizeof(asn_DEF_Test_structure_1_1_tags)
+		/sizeof(asn_DEF_Test_structure_1_1_tags[0]), /* 1 */
+	asn_DEF_Test_structure_1_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Test_structure_1_1_tags)
+		/sizeof(asn_DEF_Test_structure_1_1_tags[0]), /* 1 */
+	asn_MBR_Test_structure_1_1,
 	4,	/* Elements count */
-	&asn_DEF_Test_structure_1_specs	/* Additional specs */
+	&asn_SPC_Test_structure_1_1_specs	/* Additional specs */
 };
 
 
@@ -236,7 +236,7 @@ typedef struct Choice_1 {
 
 /*** <<< STAT-DEFS [Choice-1] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_or[] = {
+static asn_TYPE_member_t asn_MBR_or_2[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = -1 /* Ambiguous tag (CHOICE?) */,
 		.tag_mode = 0,
@@ -245,17 +245,17 @@ static asn_TYPE_member_t asn_MBR_or[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_or_tags[] = {
+static ber_tlv_tag_t asn_DEF_or_2_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_or_specs = {
+static asn_SET_OF_specifics_t asn_SPC_or_2_specs = {
 	sizeof(struct or),
 	offsetof(struct or, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_or = {
+asn_TYPE_descriptor_t asn_DEF_or_2 = {
 	"or",
 	"or",
 	SET_OF_free,
@@ -266,18 +266,18 @@ asn_TYPE_descriptor_t asn_DEF_or = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_or_tags,
-	sizeof(asn_DEF_or_tags)
-		/sizeof(asn_DEF_or_tags[0]) - 1, /* 1 */
-	asn_DEF_or_tags,	/* Same as above */
-	sizeof(asn_DEF_or_tags)
-		/sizeof(asn_DEF_or_tags[0]), /* 2 */
-	asn_MBR_or,
+	asn_DEF_or_2_tags,
+	sizeof(asn_DEF_or_2_tags)
+		/sizeof(asn_DEF_or_2_tags[0]) - 1, /* 1 */
+	asn_DEF_or_2_tags,	/* Same as above */
+	sizeof(asn_DEF_or_2_tags)
+		/sizeof(asn_DEF_or_2_tags[0]), /* 2 */
+	asn_MBR_or_2,
 	1,	/* Single element */
-	&asn_DEF_or_specs	/* Additional specs */
+	&asn_SPC_or_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_Choice_1[] = {
+static asn_TYPE_member_t asn_MBR_Choice_1_1[] = {
 	{ ATF_POINTER, 0, offsetof(struct Choice_1, choice.and),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
@@ -288,7 +288,7 @@ static asn_TYPE_member_t asn_MBR_Choice_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Choice_1, choice.or),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
-		.type = (void *)&asn_DEF_or,
+		.type = (void *)&asn_DEF_or_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "or"
 		},
@@ -307,18 +307,18 @@ static asn_TYPE_member_t asn_MBR_Choice_1[] = {
 		.name = "other"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_Choice_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice_1_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* and at 22 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* or at 23 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* not at 24 */
     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* other at 26 */
 };
-static asn_CHOICE_specifics_t asn_DEF_Choice_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice_1_1_specs = {
 	sizeof(struct Choice_1),
 	offsetof(struct Choice_1, _asn_ctx),
 	offsetof(struct Choice_1, present),
 	sizeof(((struct Choice_1 *)0)->present),
-	asn_DEF_Choice_1_tag2el,
+	asn_MAP_Choice_1_1_tag2el,
 	4,	/* Count of tags in the map */
 	0	/* Whether extensible */
 };
@@ -337,9 +337,9 @@ asn_TYPE_descriptor_t asn_DEF_Choice_1 = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_Choice_1,
+	asn_MBR_Choice_1_1,
 	4,	/* Elements count */
-	&asn_DEF_Choice_1_specs	/* Additional specs */
+	&asn_SPC_Choice_1_1_specs	/* Additional specs */
 };
 
 
@@ -377,7 +377,7 @@ typedef struct Test_structure_2 {
 
 /*** <<< STAT-DEFS [Test-structure-2] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Test_structure_2[] = {
+static asn_TYPE_member_t asn_MBR_Test_structure_2_1[] = {
 	{ ATF_POINTER, 1, offsetof(struct Test_structure_2, m1),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
@@ -386,25 +386,25 @@ static asn_TYPE_member_t asn_MBR_Test_structure_2[] = {
 		.name = "m1"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Test_structure_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Test_structure_2_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Test_structure_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Test_structure_2_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* m1 at 28 */
 };
-static uint8_t asn_DEF_Test_structure_2_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Test_structure_2_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(0 << 7)
 };
-static asn_SET_specifics_t asn_DEF_Test_structure_2_specs = {
+static asn_SET_specifics_t asn_SPC_Test_structure_2_1_specs = {
 	sizeof(struct Test_structure_2),
 	offsetof(struct Test_structure_2, _asn_ctx),
 	offsetof(struct Test_structure_2, _presence_map),
-	asn_DEF_Test_structure_2_tag2el,
+	asn_MAP_Test_structure_2_1_tag2el,
 	1,	/* Count of tags in the map */
-	asn_DEF_Test_structure_2_tag2el,	/* Same as above */
+	asn_MAP_Test_structure_2_1_tag2el,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_DEF_Test_structure_2_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Test_structure_2_1_mmap	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Test_structure_2 = {
 	"Test-structure-2",
@@ -417,15 +417,15 @@ asn_TYPE_descriptor_t asn_DEF_Test_structure_2 = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Test_structure_2_tags,
-	sizeof(asn_DEF_Test_structure_2_tags)
-		/sizeof(asn_DEF_Test_structure_2_tags[0]), /* 1 */
-	asn_DEF_Test_structure_2_tags,	/* Same as above */
-	sizeof(asn_DEF_Test_structure_2_tags)
-		/sizeof(asn_DEF_Test_structure_2_tags[0]), /* 1 */
-	asn_MBR_Test_structure_2,
+	asn_DEF_Test_structure_2_1_tags,
+	sizeof(asn_DEF_Test_structure_2_1_tags)
+		/sizeof(asn_DEF_Test_structure_2_1_tags[0]), /* 1 */
+	asn_DEF_Test_structure_2_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Test_structure_2_1_tags)
+		/sizeof(asn_DEF_Test_structure_2_1_tags[0]), /* 1 */
+	asn_MBR_Test_structure_2_1,
 	1,	/* Elements count */
-	&asn_DEF_Test_structure_2_specs	/* Additional specs */
+	&asn_SPC_Test_structure_2_1_specs	/* Additional specs */
 };
 
 
@@ -463,7 +463,7 @@ typedef struct Test_structure_3 {
 
 /*** <<< STAT-DEFS [Test-structure-3] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Test_structure_3[] = {
+static asn_TYPE_member_t asn_MBR_Test_structure_3_1[] = {
 	{ ATF_POINTER, 1, offsetof(struct Test_structure_3, m1),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
@@ -472,25 +472,25 @@ static asn_TYPE_member_t asn_MBR_Test_structure_3[] = {
 		.name = "m1"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Test_structure_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_Test_structure_3_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Test_structure_3_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Test_structure_3_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* m1 at 29 */
 };
-static uint8_t asn_DEF_Test_structure_3_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Test_structure_3_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(0 << 7)
 };
-static asn_SET_specifics_t asn_DEF_Test_structure_3_specs = {
+static asn_SET_specifics_t asn_SPC_Test_structure_3_1_specs = {
 	sizeof(struct Test_structure_3),
 	offsetof(struct Test_structure_3, _asn_ctx),
 	offsetof(struct Test_structure_3, _presence_map),
-	asn_DEF_Test_structure_3_tag2el,
+	asn_MAP_Test_structure_3_1_tag2el,
 	1,	/* Count of tags in the map */
-	asn_DEF_Test_structure_3_tag2el,	/* Same as above */
+	asn_MAP_Test_structure_3_1_tag2el,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_DEF_Test_structure_3_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Test_structure_3_1_mmap	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Test_structure_3 = {
 	"Test-structure-3",
@@ -503,14 +503,14 @@ asn_TYPE_descriptor_t asn_DEF_Test_structure_3 = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Test_structure_3_tags,
-	sizeof(asn_DEF_Test_structure_3_tags)
-		/sizeof(asn_DEF_Test_structure_3_tags[0]), /* 1 */
-	asn_DEF_Test_structure_3_tags,	/* Same as above */
-	sizeof(asn_DEF_Test_structure_3_tags)
-		/sizeof(asn_DEF_Test_structure_3_tags[0]), /* 1 */
-	asn_MBR_Test_structure_3,
+	asn_DEF_Test_structure_3_1_tags,
+	sizeof(asn_DEF_Test_structure_3_1_tags)
+		/sizeof(asn_DEF_Test_structure_3_1_tags[0]), /* 1 */
+	asn_DEF_Test_structure_3_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Test_structure_3_1_tags)
+		/sizeof(asn_DEF_Test_structure_3_1_tags[0]), /* 1 */
+	asn_MBR_Test_structure_3_1,
 	1,	/* Elements count */
-	&asn_DEF_Test_structure_3_specs	/* Additional specs */
+	&asn_SPC_Test_structure_3_1_specs	/* Additional specs */
 };
 
diff --git a/tests/44-choice-in-sequence-OK.asn1.-P b/tests/44-choice-in-sequence-OK.asn1.-P
index 80bfe9bc..7deb2dfa 100644
--- a/tests/44-choice-in-sequence-OK.asn1.-P
+++ b/tests/44-choice-in-sequence-OK.asn1.-P
@@ -68,7 +68,7 @@ typedef struct T {
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_e[] = {
+static asn_TYPE_member_t asn_MBR_e_3[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct e, choice.f),
 		.tag = (ASN_TAG_CLASS_PRIVATE | (7 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -84,21 +84,21 @@ static asn_TYPE_member_t asn_MBR_e[] = {
 		.name = "g"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_e_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_e_3_tag2el[] = {
     { (ASN_TAG_CLASS_PRIVATE | (7 << 2)), 0, 0, 0 }, /* f at 20 */
     { (ASN_TAG_CLASS_PRIVATE | (8 << 2)), 1, 0, 0 } /* g at 21 */
 };
-static asn_CHOICE_specifics_t asn_DEF_e_specs = {
+static asn_CHOICE_specifics_t asn_SPC_e_3_specs = {
 	sizeof(struct e),
 	offsetof(struct e, _asn_ctx),
 	offsetof(struct e, present),
 	sizeof(((struct e *)0)->present),
-	asn_DEF_e_tag2el,
+	asn_MAP_e_3_tag2el,
 	2,	/* Count of tags in the map */
 	0	/* Whether extensible */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_e = {
+asn_TYPE_descriptor_t asn_DEF_e_3 = {
 	"e",
 	"e",
 	CHOICE_free,
@@ -113,12 +113,12 @@ asn_TYPE_descriptor_t asn_DEF_e = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_e,
+	asn_MBR_e_3,
 	2,	/* Elements count */
-	&asn_DEF_e_specs	/* Additional specs */
+	&asn_SPC_e_3_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_h[] = {
+static asn_TYPE_member_t asn_MBR_h_4[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct h, choice.i),
 		.tag = (ASN_TAG_CLASS_PRIVATE | (1 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -134,21 +134,21 @@ static asn_TYPE_member_t asn_MBR_h[] = {
 		.name = "j"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_h_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_h_4_tag2el[] = {
     { (ASN_TAG_CLASS_PRIVATE | (1 << 2)), 0, 0, 0 }, /* i at 24 */
     { (ASN_TAG_CLASS_PRIVATE | (2 << 2)), 1, 0, 0 } /* j at 25 */
 };
-static asn_CHOICE_specifics_t asn_DEF_h_specs = {
+static asn_CHOICE_specifics_t asn_SPC_h_4_specs = {
 	sizeof(struct h),
 	offsetof(struct h, _asn_ctx),
 	offsetof(struct h, present),
 	sizeof(((struct h *)0)->present),
-	asn_DEF_h_tag2el,
+	asn_MAP_h_4_tag2el,
 	2,	/* Count of tags in the map */
 	0	/* Whether extensible */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_h = {
+asn_TYPE_descriptor_t asn_DEF_h_4 = {
 	"h",
 	"h",
 	CHOICE_free,
@@ -163,12 +163,12 @@ asn_TYPE_descriptor_t asn_DEF_h = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_h,
+	asn_MBR_h_4,
 	2,	/* Elements count */
-	&asn_DEF_h_specs	/* Additional specs */
+	&asn_SPC_h_4_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_b[] = {
+static asn_TYPE_member_t asn_MBR_b_2[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct b, choice.c),
 		.tag = (ASN_TAG_CLASS_PRIVATE | (5 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -186,36 +186,36 @@ static asn_TYPE_member_t asn_MBR_b[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct b, choice.e),
 		.tag = -1 /* Ambiguous tag (CHOICE?) */,
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_e,
+		.type = (void *)&asn_DEF_e_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "e"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct b, choice.h),
 		.tag = (ASN_TAG_CLASS_PRIVATE | (9 << 2)),
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
-		.type = (void *)&asn_DEF_h,
+		.type = (void *)&asn_DEF_h_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "h"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_b_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_b_2_tag2el[] = {
     { (ASN_TAG_CLASS_PRIVATE | (5 << 2)), 0, 0, 0 }, /* c at 17 */
     { (ASN_TAG_CLASS_PRIVATE | (6 << 2)), 1, 0, 0 }, /* d at 18 */
     { (ASN_TAG_CLASS_PRIVATE | (7 << 2)), 2, 0, 0 }, /* f at 20 */
     { (ASN_TAG_CLASS_PRIVATE | (8 << 2)), 2, 0, 0 }, /* g at 21 */
     { (ASN_TAG_CLASS_PRIVATE | (9 << 2)), 3, 0, 0 } /* h at 24 */
 };
-static asn_CHOICE_specifics_t asn_DEF_b_specs = {
+static asn_CHOICE_specifics_t asn_SPC_b_2_specs = {
 	sizeof(struct b),
 	offsetof(struct b, _asn_ctx),
 	offsetof(struct b, present),
 	sizeof(((struct b *)0)->present),
-	asn_DEF_b_tag2el,
+	asn_MAP_b_2_tag2el,
 	5,	/* Count of tags in the map */
 	0	/* Whether extensible */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_b = {
+asn_TYPE_descriptor_t asn_DEF_b_2 = {
 	"b",
 	"b",
 	CHOICE_free,
@@ -230,12 +230,12 @@ asn_TYPE_descriptor_t asn_DEF_b = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_b,
+	asn_MBR_b_2,
 	4,	/* Elements count */
-	&asn_DEF_b_specs	/* Additional specs */
+	&asn_SPC_b_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_T[] = {
+static asn_TYPE_member_t asn_MBR_T_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T, a),
 		.tag = (ASN_TAG_CLASS_PRIVATE | (2 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -246,16 +246,16 @@ static asn_TYPE_member_t asn_MBR_T[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T, b),
 		.tag = -1 /* Ambiguous tag (CHOICE?) */,
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_b,
+		.type = (void *)&asn_DEF_b_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
 	(ASN_TAG_CLASS_PRIVATE | (1 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
     { (ASN_TAG_CLASS_PRIVATE | (2 << 2)), 0, 0, 0 }, /* a at 15 */
     { (ASN_TAG_CLASS_PRIVATE | (5 << 2)), 1, 0, 0 }, /* c at 17 */
     { (ASN_TAG_CLASS_PRIVATE | (6 << 2)), 1, 0, 0 }, /* d at 18 */
@@ -263,10 +263,10 @@ static asn_TYPE_tag2member_t asn_DEF_T_tag2el[] = {
     { (ASN_TAG_CLASS_PRIVATE | (8 << 2)), 1, 0, 0 }, /* g at 21 */
     { (ASN_TAG_CLASS_PRIVATE | (9 << 2)), 1, 0, 0 } /* h at 24 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_T_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T_1_specs = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
-	asn_DEF_T_tag2el,
+	asn_MAP_T_1_tag2el,
 	6,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -282,14 +282,14 @@ asn_TYPE_descriptor_t asn_DEF_T = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_tags,
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]) - 1, /* 1 */
-	asn_DEF_T_tags,	/* Same as above */
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 2 */
-	asn_MBR_T,
+	asn_DEF_T_1_tags,
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]) - 1, /* 1 */
+	asn_DEF_T_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 2 */
+	asn_MBR_T_1,
 	2,	/* Elements count */
-	&asn_DEF_T_specs	/* Additional specs */
+	&asn_SPC_T_1_specs	/* Additional specs */
 };
 
diff --git a/tests/46-redefine-OK.asn1.-PR b/tests/46-redefine-OK.asn1.-PR
index 5f9a6e28..7a2b69be 100644
--- a/tests/46-redefine-OK.asn1.-PR
+++ b/tests/46-redefine-OK.asn1.-PR
@@ -39,7 +39,7 @@ typedef struct ConstructedType {
 
 /*** <<< STAT-DEFS [ConstructedType] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_ConstructedType[] = {
+static asn_TYPE_member_t asn_MBR_ConstructedType_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct ConstructedType, field),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -48,16 +48,16 @@ static asn_TYPE_member_t asn_MBR_ConstructedType[] = {
 		.name = "field"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ConstructedType_tags[] = {
+static ber_tlv_tag_t asn_DEF_ConstructedType_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_ConstructedType_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ConstructedType_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 0, 0, 0 } /* field at 18 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_ConstructedType_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_ConstructedType_1_specs = {
 	sizeof(struct ConstructedType),
 	offsetof(struct ConstructedType, _asn_ctx),
-	asn_DEF_ConstructedType_tag2el,
+	asn_MAP_ConstructedType_1_tag2el,
 	1,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -73,15 +73,15 @@ asn_TYPE_descriptor_t asn_DEF_ConstructedType = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ConstructedType_tags,
-	sizeof(asn_DEF_ConstructedType_tags)
-		/sizeof(asn_DEF_ConstructedType_tags[0]), /* 1 */
-	asn_DEF_ConstructedType_tags,	/* Same as above */
-	sizeof(asn_DEF_ConstructedType_tags)
-		/sizeof(asn_DEF_ConstructedType_tags[0]), /* 1 */
-	asn_MBR_ConstructedType,
+	asn_DEF_ConstructedType_1_tags,
+	sizeof(asn_DEF_ConstructedType_1_tags)
+		/sizeof(asn_DEF_ConstructedType_1_tags[0]), /* 1 */
+	asn_DEF_ConstructedType_1_tags,	/* Same as above */
+	sizeof(asn_DEF_ConstructedType_1_tags)
+		/sizeof(asn_DEF_ConstructedType_1_tags[0]), /* 1 */
+	asn_MBR_ConstructedType_1,
 	1,	/* Elements count */
-	&asn_DEF_ConstructedType_specs	/* Additional specs */
+	&asn_SPC_ConstructedType_1_specs	/* Additional specs */
 };
 
 
@@ -120,7 +120,7 @@ T_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_ConstructedType.free_struct;
 	td->print_struct   = asn_DEF_ConstructedType.print_struct;
 	td->ber_decoder    = asn_DEF_ConstructedType.ber_decoder;
@@ -135,21 +135,21 @@ T_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -157,14 +157,14 @@ asn_enc_rval_t
 T_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -172,14 +172,14 @@ asn_enc_rval_t
 T_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
@@ -194,12 +194,12 @@ asn_TYPE_descriptor_t asn_DEF_T = {
 	T_decode_xer,
 	T_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_tags,
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]) - 1, /* 1 */
-	asn_DEF_T_tags,	/* Same as above */
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 2 */
+	asn_DEF_T_0_tags,
+	sizeof(asn_DEF_T_0_tags)
+		/sizeof(asn_DEF_T_0_tags[0]) - 1, /* 1 */
+	asn_DEF_T_0_tags,	/* Same as above */
+	sizeof(asn_DEF_T_0_tags)
+		/sizeof(asn_DEF_T_0_tags[0]), /* 2 */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
diff --git a/tests/47-set-ext-OK.asn1.-P b/tests/47-set-ext-OK.asn1.-P
index d6397013..e91110dc 100644
--- a/tests/47-set-ext-OK.asn1.-P
+++ b/tests/47-set-ext-OK.asn1.-P
@@ -35,7 +35,7 @@ typedef struct T1 {
 
 /*** <<< STAT-DEFS [T1] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T1[] = {
+static asn_TYPE_member_t asn_MBR_T1_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T1, i),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -44,25 +44,25 @@ static asn_TYPE_member_t asn_MBR_T1[] = {
 		.name = "i"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T1_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 14 */
 };
-static uint8_t asn_DEF_T1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_T1_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_DEF_T1_specs = {
+static asn_SET_specifics_t asn_SPC_T1_1_specs = {
 	sizeof(struct T1),
 	offsetof(struct T1, _asn_ctx),
 	offsetof(struct T1, _presence_map),
-	asn_DEF_T1_tag2el,
+	asn_MAP_T1_1_tag2el,
 	1,	/* Count of tags in the map */
-	asn_DEF_T1_tag2el,	/* Same as above */
+	asn_MAP_T1_1_tag2el,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_DEF_T1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_T1_1_mmap	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_T1 = {
 	"T1",
@@ -75,15 +75,15 @@ asn_TYPE_descriptor_t asn_DEF_T1 = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T1_tags,
-	sizeof(asn_DEF_T1_tags)
-		/sizeof(asn_DEF_T1_tags[0]), /* 1 */
-	asn_DEF_T1_tags,	/* Same as above */
-	sizeof(asn_DEF_T1_tags)
-		/sizeof(asn_DEF_T1_tags[0]), /* 1 */
-	asn_MBR_T1,
+	asn_DEF_T1_1_tags,
+	sizeof(asn_DEF_T1_1_tags)
+		/sizeof(asn_DEF_T1_1_tags[0]), /* 1 */
+	asn_DEF_T1_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T1_1_tags)
+		/sizeof(asn_DEF_T1_1_tags[0]), /* 1 */
+	asn_MBR_T1_1,
 	1,	/* Elements count */
-	&asn_DEF_T1_specs	/* Additional specs */
+	&asn_SPC_T1_1_specs	/* Additional specs */
 };
 
 
@@ -123,7 +123,7 @@ typedef struct T2 {
 
 /*** <<< STAT-DEFS [T2] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T2[] = {
+static asn_TYPE_member_t asn_MBR_T2_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T2, i),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -132,25 +132,25 @@ static asn_TYPE_member_t asn_MBR_T2[] = {
 		.name = "i"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T2_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T2_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 15 */
 };
-static uint8_t asn_DEF_T2_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_T2_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_DEF_T2_specs = {
+static asn_SET_specifics_t asn_SPC_T2_1_specs = {
 	sizeof(struct T2),
 	offsetof(struct T2, _asn_ctx),
 	offsetof(struct T2, _presence_map),
-	asn_DEF_T2_tag2el,
+	asn_MAP_T2_1_tag2el,
 	1,	/* Count of tags in the map */
-	asn_DEF_T2_tag2el,	/* Same as above */
+	asn_MAP_T2_1_tag2el,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_DEF_T2_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_T2_1_mmap	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_T2 = {
 	"T2",
@@ -163,15 +163,15 @@ asn_TYPE_descriptor_t asn_DEF_T2 = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T2_tags,
-	sizeof(asn_DEF_T2_tags)
-		/sizeof(asn_DEF_T2_tags[0]), /* 1 */
-	asn_DEF_T2_tags,	/* Same as above */
-	sizeof(asn_DEF_T2_tags)
-		/sizeof(asn_DEF_T2_tags[0]), /* 1 */
-	asn_MBR_T2,
+	asn_DEF_T2_1_tags,
+	sizeof(asn_DEF_T2_1_tags)
+		/sizeof(asn_DEF_T2_1_tags[0]), /* 1 */
+	asn_DEF_T2_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T2_1_tags)
+		/sizeof(asn_DEF_T2_1_tags[0]), /* 1 */
+	asn_MBR_T2_1,
 	1,	/* Elements count */
-	&asn_DEF_T2_specs	/* Additional specs */
+	&asn_SPC_T2_1_specs	/* Additional specs */
 };
 
 
@@ -208,7 +208,7 @@ typedef struct T3 {
 
 /*** <<< STAT-DEFS [T3] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T3[] = {
+static asn_TYPE_member_t asn_MBR_T3_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T3, choice.i),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -217,15 +217,15 @@ static asn_TYPE_member_t asn_MBR_T3[] = {
 		.name = "i"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_T3_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T3_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 16 */
 };
-static asn_CHOICE_specifics_t asn_DEF_T3_specs = {
+static asn_CHOICE_specifics_t asn_SPC_T3_1_specs = {
 	sizeof(struct T3),
 	offsetof(struct T3, _asn_ctx),
 	offsetof(struct T3, present),
 	sizeof(((struct T3 *)0)->present),
-	asn_DEF_T3_tag2el,
+	asn_MAP_T3_1_tag2el,
 	1,	/* Count of tags in the map */
 	1	/* Whether extensible */
 };
@@ -244,9 +244,9 @@ asn_TYPE_descriptor_t asn_DEF_T3 = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_T3,
+	asn_MBR_T3_1,
 	1,	/* Elements count */
-	&asn_DEF_T3_specs	/* Additional specs */
+	&asn_SPC_T3_1_specs	/* Additional specs */
 };
 
 
@@ -283,7 +283,7 @@ typedef struct T4 {
 
 /*** <<< STAT-DEFS [T4] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T4[] = {
+static asn_TYPE_member_t asn_MBR_T4_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T4, choice.i),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -292,15 +292,15 @@ static asn_TYPE_member_t asn_MBR_T4[] = {
 		.name = "i"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_T4_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T4_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 17 */
 };
-static asn_CHOICE_specifics_t asn_DEF_T4_specs = {
+static asn_CHOICE_specifics_t asn_SPC_T4_1_specs = {
 	sizeof(struct T4),
 	offsetof(struct T4, _asn_ctx),
 	offsetof(struct T4, present),
 	sizeof(((struct T4 *)0)->present),
-	asn_DEF_T4_tag2el,
+	asn_MAP_T4_1_tag2el,
 	1,	/* Count of tags in the map */
 	1	/* Whether extensible */
 };
@@ -319,8 +319,8 @@ asn_TYPE_descriptor_t asn_DEF_T4 = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_T4,
+	asn_MBR_T4_1,
 	1,	/* Elements count */
-	&asn_DEF_T4_specs	/* Additional specs */
+	&asn_SPC_T4_1_specs	/* Additional specs */
 };
 
diff --git a/tests/50-constraint-OK.asn1.-P b/tests/50-constraint-OK.asn1.-P
index 07c95cc8..01131bf6 100644
--- a/tests/50-constraint-OK.asn1.-P
+++ b/tests/50-constraint-OK.asn1.-P
@@ -72,7 +72,7 @@ Int2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Int2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Int2_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Int1.free_struct;
 	td->print_struct   = asn_DEF_Int1.print_struct;
 	td->ber_decoder    = asn_DEF_Int1.ber_decoder;
@@ -87,21 +87,21 @@ Int2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Int2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Int2_inherit_TYPE_descriptor(td);
+	Int2_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Int2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Int2_inherit_TYPE_descriptor(td);
+	Int2_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Int2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Int2_inherit_TYPE_descriptor(td);
+	Int2_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -109,14 +109,14 @@ asn_enc_rval_t
 Int2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Int2_inherit_TYPE_descriptor(td);
+	Int2_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Int2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Int2_inherit_TYPE_descriptor(td);
+	Int2_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -124,14 +124,14 @@ asn_enc_rval_t
 Int2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Int2_inherit_TYPE_descriptor(td);
+	Int2_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Int2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int2_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int2 = {
@@ -145,12 +145,12 @@ asn_TYPE_descriptor_t asn_DEF_Int2 = {
 	Int2_decode_xer,
 	Int2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int2_tags,
-	sizeof(asn_DEF_Int2_tags)
-		/sizeof(asn_DEF_Int2_tags[0]), /* 1 */
-	asn_DEF_Int2_tags,	/* Same as above */
-	sizeof(asn_DEF_Int2_tags)
-		/sizeof(asn_DEF_Int2_tags[0]), /* 1 */
+	asn_DEF_Int2_0_tags,
+	sizeof(asn_DEF_Int2_0_tags)
+		/sizeof(asn_DEF_Int2_0_tags[0]), /* 1 */
+	asn_DEF_Int2_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Int2_0_tags)
+		/sizeof(asn_DEF_Int2_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -214,7 +214,7 @@ Int3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Int3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Int3_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Int2.free_struct;
 	td->print_struct   = asn_DEF_Int2.print_struct;
 	td->ber_decoder    = asn_DEF_Int2.ber_decoder;
@@ -229,21 +229,21 @@ Int3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Int3_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Int3_inherit_TYPE_descriptor(td);
+	Int3_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Int3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Int3_inherit_TYPE_descriptor(td);
+	Int3_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Int3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Int3_inherit_TYPE_descriptor(td);
+	Int3_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -251,14 +251,14 @@ asn_enc_rval_t
 Int3_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Int3_inherit_TYPE_descriptor(td);
+	Int3_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Int3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Int3_inherit_TYPE_descriptor(td);
+	Int3_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -266,14 +266,14 @@ asn_enc_rval_t
 Int3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Int3_inherit_TYPE_descriptor(td);
+	Int3_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Int3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int3_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int3_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int3 = {
@@ -287,12 +287,12 @@ asn_TYPE_descriptor_t asn_DEF_Int3 = {
 	Int3_decode_xer,
 	Int3_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int3_tags,
-	sizeof(asn_DEF_Int3_tags)
-		/sizeof(asn_DEF_Int3_tags[0]), /* 1 */
-	asn_DEF_Int3_tags,	/* Same as above */
-	sizeof(asn_DEF_Int3_tags)
-		/sizeof(asn_DEF_Int3_tags[0]), /* 1 */
+	asn_DEF_Int3_0_tags,
+	sizeof(asn_DEF_Int3_0_tags)
+		/sizeof(asn_DEF_Int3_0_tags[0]), /* 1 */
+	asn_DEF_Int3_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Int3_0_tags)
+		/sizeof(asn_DEF_Int3_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -356,7 +356,7 @@ Int4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Int4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Int4_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Int3.free_struct;
 	td->print_struct   = asn_DEF_Int3.print_struct;
 	td->ber_decoder    = asn_DEF_Int3.ber_decoder;
@@ -371,21 +371,21 @@ Int4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Int4_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Int4_inherit_TYPE_descriptor(td);
+	Int4_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Int4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Int4_inherit_TYPE_descriptor(td);
+	Int4_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Int4_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Int4_inherit_TYPE_descriptor(td);
+	Int4_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -393,14 +393,14 @@ asn_enc_rval_t
 Int4_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Int4_inherit_TYPE_descriptor(td);
+	Int4_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Int4_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Int4_inherit_TYPE_descriptor(td);
+	Int4_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -408,14 +408,14 @@ asn_enc_rval_t
 Int4_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Int4_inherit_TYPE_descriptor(td);
+	Int4_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Int4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int4_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int4_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int4 = {
@@ -429,12 +429,12 @@ asn_TYPE_descriptor_t asn_DEF_Int4 = {
 	Int4_decode_xer,
 	Int4_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int4_tags,
-	sizeof(asn_DEF_Int4_tags)
-		/sizeof(asn_DEF_Int4_tags[0]), /* 1 */
-	asn_DEF_Int4_tags,	/* Same as above */
-	sizeof(asn_DEF_Int4_tags)
-		/sizeof(asn_DEF_Int4_tags[0]), /* 1 */
+	asn_DEF_Int4_0_tags,
+	sizeof(asn_DEF_Int4_0_tags)
+		/sizeof(asn_DEF_Int4_0_tags[0]), /* 1 */
+	asn_DEF_Int4_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Int4_0_tags)
+		/sizeof(asn_DEF_Int4_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -498,7 +498,7 @@ Int5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Int5_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Int5_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Int4.free_struct;
 	td->print_struct   = asn_DEF_Int4.print_struct;
 	td->ber_decoder    = asn_DEF_Int4.ber_decoder;
@@ -513,21 +513,21 @@ Int5_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Int5_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Int5_inherit_TYPE_descriptor(td);
+	Int5_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Int5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Int5_inherit_TYPE_descriptor(td);
+	Int5_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Int5_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Int5_inherit_TYPE_descriptor(td);
+	Int5_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -535,14 +535,14 @@ asn_enc_rval_t
 Int5_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Int5_inherit_TYPE_descriptor(td);
+	Int5_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Int5_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Int5_inherit_TYPE_descriptor(td);
+	Int5_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -550,14 +550,14 @@ asn_enc_rval_t
 Int5_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Int5_inherit_TYPE_descriptor(td);
+	Int5_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Int5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int5_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int5_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int5 = {
@@ -571,12 +571,12 @@ asn_TYPE_descriptor_t asn_DEF_Int5 = {
 	Int5_decode_xer,
 	Int5_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int5_tags,
-	sizeof(asn_DEF_Int5_tags)
-		/sizeof(asn_DEF_Int5_tags[0]), /* 1 */
-	asn_DEF_Int5_tags,	/* Same as above */
-	sizeof(asn_DEF_Int5_tags)
-		/sizeof(asn_DEF_Int5_tags[0]), /* 1 */
+	asn_DEF_Int5_0_tags,
+	sizeof(asn_DEF_Int5_0_tags)
+		/sizeof(asn_DEF_Int5_0_tags[0]), /* 1 */
+	asn_DEF_Int5_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Int5_0_tags)
+		/sizeof(asn_DEF_Int5_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -640,7 +640,7 @@ ExtensibleExtensions_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-ExtensibleExtensions_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+ExtensibleExtensions_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_INTEGER.free_struct;
 	td->print_struct   = asn_DEF_INTEGER.print_struct;
 	td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
@@ -655,21 +655,21 @@ ExtensibleExtensions_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 ExtensibleExtensions_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	ExtensibleExtensions_inherit_TYPE_descriptor(td);
+	ExtensibleExtensions_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 ExtensibleExtensions_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	ExtensibleExtensions_inherit_TYPE_descriptor(td);
+	ExtensibleExtensions_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 ExtensibleExtensions_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	ExtensibleExtensions_inherit_TYPE_descriptor(td);
+	ExtensibleExtensions_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -677,14 +677,14 @@ asn_enc_rval_t
 ExtensibleExtensions_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	ExtensibleExtensions_inherit_TYPE_descriptor(td);
+	ExtensibleExtensions_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 ExtensibleExtensions_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	ExtensibleExtensions_inherit_TYPE_descriptor(td);
+	ExtensibleExtensions_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -692,14 +692,14 @@ asn_enc_rval_t
 ExtensibleExtensions_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	ExtensibleExtensions_inherit_TYPE_descriptor(td);
+	ExtensibleExtensions_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [ExtensibleExtensions] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_ExtensibleExtensions_tags[] = {
+static ber_tlv_tag_t asn_DEF_ExtensibleExtensions_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_ExtensibleExtensions = {
@@ -713,12 +713,12 @@ asn_TYPE_descriptor_t asn_DEF_ExtensibleExtensions = {
 	ExtensibleExtensions_decode_xer,
 	ExtensibleExtensions_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ExtensibleExtensions_tags,
-	sizeof(asn_DEF_ExtensibleExtensions_tags)
-		/sizeof(asn_DEF_ExtensibleExtensions_tags[0]), /* 1 */
-	asn_DEF_ExtensibleExtensions_tags,	/* Same as above */
-	sizeof(asn_DEF_ExtensibleExtensions_tags)
-		/sizeof(asn_DEF_ExtensibleExtensions_tags[0]), /* 1 */
+	asn_DEF_ExtensibleExtensions_0_tags,
+	sizeof(asn_DEF_ExtensibleExtensions_0_tags)
+		/sizeof(asn_DEF_ExtensibleExtensions_0_tags[0]), /* 1 */
+	asn_DEF_ExtensibleExtensions_0_tags,	/* Same as above */
+	sizeof(asn_DEF_ExtensibleExtensions_0_tags)
+		/sizeof(asn_DEF_ExtensibleExtensions_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -813,7 +813,7 @@ Str2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Str2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Str2_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Str1.free_struct;
 	td->print_struct   = asn_DEF_Str1.print_struct;
 	td->ber_decoder    = asn_DEF_Str1.ber_decoder;
@@ -828,21 +828,21 @@ Str2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Str2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Str2_inherit_TYPE_descriptor(td);
+	Str2_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Str2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Str2_inherit_TYPE_descriptor(td);
+	Str2_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Str2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Str2_inherit_TYPE_descriptor(td);
+	Str2_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -850,14 +850,14 @@ asn_enc_rval_t
 Str2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Str2_inherit_TYPE_descriptor(td);
+	Str2_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Str2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Str2_inherit_TYPE_descriptor(td);
+	Str2_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -865,14 +865,14 @@ asn_enc_rval_t
 Str2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Str2_inherit_TYPE_descriptor(td);
+	Str2_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Str2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Str2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Str2_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Str2 = {
@@ -886,12 +886,12 @@ asn_TYPE_descriptor_t asn_DEF_Str2 = {
 	Str2_decode_xer,
 	Str2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Str2_tags,
-	sizeof(asn_DEF_Str2_tags)
-		/sizeof(asn_DEF_Str2_tags[0]), /* 1 */
-	asn_DEF_Str2_tags,	/* Same as above */
-	sizeof(asn_DEF_Str2_tags)
-		/sizeof(asn_DEF_Str2_tags[0]), /* 1 */
+	asn_DEF_Str2_0_tags,
+	sizeof(asn_DEF_Str2_0_tags)
+		/sizeof(asn_DEF_Str2_0_tags[0]), /* 1 */
+	asn_DEF_Str2_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Str2_0_tags)
+		/sizeof(asn_DEF_Str2_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -978,7 +978,7 @@ Str3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Str3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Str3_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Str2.free_struct;
 	td->print_struct   = asn_DEF_Str2.print_struct;
 	td->ber_decoder    = asn_DEF_Str2.ber_decoder;
@@ -993,21 +993,21 @@ Str3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Str3_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Str3_inherit_TYPE_descriptor(td);
+	Str3_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Str3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Str3_inherit_TYPE_descriptor(td);
+	Str3_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Str3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Str3_inherit_TYPE_descriptor(td);
+	Str3_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -1015,14 +1015,14 @@ asn_enc_rval_t
 Str3_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Str3_inherit_TYPE_descriptor(td);
+	Str3_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Str3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Str3_inherit_TYPE_descriptor(td);
+	Str3_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -1030,14 +1030,14 @@ asn_enc_rval_t
 Str3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Str3_inherit_TYPE_descriptor(td);
+	Str3_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Str3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Str3_tags[] = {
+static ber_tlv_tag_t asn_DEF_Str3_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Str3 = {
@@ -1051,12 +1051,12 @@ asn_TYPE_descriptor_t asn_DEF_Str3 = {
 	Str3_decode_xer,
 	Str3_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Str3_tags,
-	sizeof(asn_DEF_Str3_tags)
-		/sizeof(asn_DEF_Str3_tags[0]), /* 1 */
-	asn_DEF_Str3_tags,	/* Same as above */
-	sizeof(asn_DEF_Str3_tags)
-		/sizeof(asn_DEF_Str3_tags[0]), /* 1 */
+	asn_DEF_Str3_0_tags,
+	sizeof(asn_DEF_Str3_0_tags)
+		/sizeof(asn_DEF_Str3_0_tags[0]), /* 1 */
+	asn_DEF_Str3_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Str3_0_tags)
+		/sizeof(asn_DEF_Str3_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1129,7 +1129,7 @@ Str4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Str4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Str4_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_IA5String.free_struct;
 	td->print_struct   = asn_DEF_IA5String.print_struct;
 	td->ber_decoder    = asn_DEF_IA5String.ber_decoder;
@@ -1144,21 +1144,21 @@ Str4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Str4_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Str4_inherit_TYPE_descriptor(td);
+	Str4_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Str4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Str4_inherit_TYPE_descriptor(td);
+	Str4_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Str4_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Str4_inherit_TYPE_descriptor(td);
+	Str4_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -1166,14 +1166,14 @@ asn_enc_rval_t
 Str4_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Str4_inherit_TYPE_descriptor(td);
+	Str4_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Str4_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Str4_inherit_TYPE_descriptor(td);
+	Str4_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -1181,14 +1181,14 @@ asn_enc_rval_t
 Str4_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Str4_inherit_TYPE_descriptor(td);
+	Str4_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Str4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Str4_tags[] = {
+static ber_tlv_tag_t asn_DEF_Str4_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Str4 = {
@@ -1202,12 +1202,12 @@ asn_TYPE_descriptor_t asn_DEF_Str4 = {
 	Str4_decode_xer,
 	Str4_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Str4_tags,
-	sizeof(asn_DEF_Str4_tags)
-		/sizeof(asn_DEF_Str4_tags[0]), /* 1 */
-	asn_DEF_Str4_tags,	/* Same as above */
-	sizeof(asn_DEF_Str4_tags)
-		/sizeof(asn_DEF_Str4_tags[0]), /* 1 */
+	asn_DEF_Str4_0_tags,
+	sizeof(asn_DEF_Str4_0_tags)
+		/sizeof(asn_DEF_Str4_0_tags[0]), /* 1 */
+	asn_DEF_Str4_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Str4_0_tags)
+		/sizeof(asn_DEF_Str4_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1280,7 +1280,7 @@ PER_Visible_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-PER_Visible_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+PER_Visible_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_IA5String.free_struct;
 	td->print_struct   = asn_DEF_IA5String.print_struct;
 	td->ber_decoder    = asn_DEF_IA5String.ber_decoder;
@@ -1295,21 +1295,21 @@ PER_Visible_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 PER_Visible_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	PER_Visible_inherit_TYPE_descriptor(td);
+	PER_Visible_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 PER_Visible_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	PER_Visible_inherit_TYPE_descriptor(td);
+	PER_Visible_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 PER_Visible_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	PER_Visible_inherit_TYPE_descriptor(td);
+	PER_Visible_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -1317,14 +1317,14 @@ asn_enc_rval_t
 PER_Visible_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	PER_Visible_inherit_TYPE_descriptor(td);
+	PER_Visible_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 PER_Visible_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	PER_Visible_inherit_TYPE_descriptor(td);
+	PER_Visible_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -1332,14 +1332,14 @@ asn_enc_rval_t
 PER_Visible_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	PER_Visible_inherit_TYPE_descriptor(td);
+	PER_Visible_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [PER-Visible] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_PER_Visible_tags[] = {
+static ber_tlv_tag_t asn_DEF_PER_Visible_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_PER_Visible = {
@@ -1353,12 +1353,12 @@ asn_TYPE_descriptor_t asn_DEF_PER_Visible = {
 	PER_Visible_decode_xer,
 	PER_Visible_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_PER_Visible_tags,
-	sizeof(asn_DEF_PER_Visible_tags)
-		/sizeof(asn_DEF_PER_Visible_tags[0]), /* 1 */
-	asn_DEF_PER_Visible_tags,	/* Same as above */
-	sizeof(asn_DEF_PER_Visible_tags)
-		/sizeof(asn_DEF_PER_Visible_tags[0]), /* 1 */
+	asn_DEF_PER_Visible_0_tags,
+	sizeof(asn_DEF_PER_Visible_0_tags)
+		/sizeof(asn_DEF_PER_Visible_0_tags[0]), /* 1 */
+	asn_DEF_PER_Visible_0_tags,	/* Same as above */
+	sizeof(asn_DEF_PER_Visible_0_tags)
+		/sizeof(asn_DEF_PER_Visible_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1431,7 +1431,7 @@ PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-PER_Visible_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+PER_Visible_2_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_PER_Visible.free_struct;
 	td->print_struct   = asn_DEF_PER_Visible.print_struct;
 	td->ber_decoder    = asn_DEF_PER_Visible.ber_decoder;
@@ -1446,21 +1446,21 @@ PER_Visible_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 PER_Visible_2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	PER_Visible_2_inherit_TYPE_descriptor(td);
+	PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 PER_Visible_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	PER_Visible_2_inherit_TYPE_descriptor(td);
+	PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 PER_Visible_2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	PER_Visible_2_inherit_TYPE_descriptor(td);
+	PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -1468,14 +1468,14 @@ asn_enc_rval_t
 PER_Visible_2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	PER_Visible_2_inherit_TYPE_descriptor(td);
+	PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 PER_Visible_2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	PER_Visible_2_inherit_TYPE_descriptor(td);
+	PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -1483,14 +1483,14 @@ asn_enc_rval_t
 PER_Visible_2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	PER_Visible_2_inherit_TYPE_descriptor(td);
+	PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [PER-Visible-2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_PER_Visible_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_PER_Visible_2_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_PER_Visible_2 = {
@@ -1504,12 +1504,12 @@ asn_TYPE_descriptor_t asn_DEF_PER_Visible_2 = {
 	PER_Visible_2_decode_xer,
 	PER_Visible_2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_PER_Visible_2_tags,
-	sizeof(asn_DEF_PER_Visible_2_tags)
-		/sizeof(asn_DEF_PER_Visible_2_tags[0]), /* 1 */
-	asn_DEF_PER_Visible_2_tags,	/* Same as above */
-	sizeof(asn_DEF_PER_Visible_2_tags)
-		/sizeof(asn_DEF_PER_Visible_2_tags[0]), /* 1 */
+	asn_DEF_PER_Visible_2_0_tags,
+	sizeof(asn_DEF_PER_Visible_2_0_tags)
+		/sizeof(asn_DEF_PER_Visible_2_0_tags[0]), /* 1 */
+	asn_DEF_PER_Visible_2_0_tags,	/* Same as above */
+	sizeof(asn_DEF_PER_Visible_2_0_tags)
+		/sizeof(asn_DEF_PER_Visible_2_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1582,7 +1582,7 @@ Not_PER_Visible_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Not_PER_Visible_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Not_PER_Visible_1_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_PER_Visible.free_struct;
 	td->print_struct   = asn_DEF_PER_Visible.print_struct;
 	td->ber_decoder    = asn_DEF_PER_Visible.ber_decoder;
@@ -1597,21 +1597,21 @@ Not_PER_Visible_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Not_PER_Visible_1_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Not_PER_Visible_1_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_1_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Not_PER_Visible_1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_1_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_1_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Not_PER_Visible_1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Not_PER_Visible_1_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_1_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -1619,14 +1619,14 @@ asn_enc_rval_t
 Not_PER_Visible_1_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_1_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_1_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Not_PER_Visible_1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Not_PER_Visible_1_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_1_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -1634,14 +1634,14 @@ asn_enc_rval_t
 Not_PER_Visible_1_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_1_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_1_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Not-PER-Visible-1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Not_PER_Visible_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_1_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_1 = {
@@ -1655,12 +1655,12 @@ asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_1 = {
 	Not_PER_Visible_1_decode_xer,
 	Not_PER_Visible_1_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Not_PER_Visible_1_tags,
-	sizeof(asn_DEF_Not_PER_Visible_1_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_1_tags[0]), /* 1 */
-	asn_DEF_Not_PER_Visible_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Not_PER_Visible_1_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_1_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_1_0_tags,
+	sizeof(asn_DEF_Not_PER_Visible_1_0_tags)
+		/sizeof(asn_DEF_Not_PER_Visible_1_0_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_1_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_1_0_tags)
+		/sizeof(asn_DEF_Not_PER_Visible_1_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1733,7 +1733,7 @@ Not_PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Not_PER_Visible_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Not_PER_Visible_2_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_PER_Visible.free_struct;
 	td->print_struct   = asn_DEF_PER_Visible.print_struct;
 	td->ber_decoder    = asn_DEF_PER_Visible.ber_decoder;
@@ -1748,21 +1748,21 @@ Not_PER_Visible_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Not_PER_Visible_2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Not_PER_Visible_2_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Not_PER_Visible_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_2_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Not_PER_Visible_2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Not_PER_Visible_2_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -1770,14 +1770,14 @@ asn_enc_rval_t
 Not_PER_Visible_2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_2_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Not_PER_Visible_2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Not_PER_Visible_2_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -1785,14 +1785,14 @@ asn_enc_rval_t
 Not_PER_Visible_2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_2_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_2_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Not-PER-Visible-2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Not_PER_Visible_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_2_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_2 = {
@@ -1806,12 +1806,12 @@ asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_2 = {
 	Not_PER_Visible_2_decode_xer,
 	Not_PER_Visible_2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Not_PER_Visible_2_tags,
-	sizeof(asn_DEF_Not_PER_Visible_2_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_2_tags[0]), /* 1 */
-	asn_DEF_Not_PER_Visible_2_tags,	/* Same as above */
-	sizeof(asn_DEF_Not_PER_Visible_2_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_2_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_2_0_tags,
+	sizeof(asn_DEF_Not_PER_Visible_2_0_tags)
+		/sizeof(asn_DEF_Not_PER_Visible_2_0_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_2_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_2_0_tags)
+		/sizeof(asn_DEF_Not_PER_Visible_2_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1884,7 +1884,7 @@ Not_PER_Visible_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Not_PER_Visible_3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Not_PER_Visible_3_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_PER_Visible.free_struct;
 	td->print_struct   = asn_DEF_PER_Visible.print_struct;
 	td->ber_decoder    = asn_DEF_PER_Visible.ber_decoder;
@@ -1899,21 +1899,21 @@ Not_PER_Visible_3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Not_PER_Visible_3_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Not_PER_Visible_3_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_3_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Not_PER_Visible_3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_3_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_3_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Not_PER_Visible_3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Not_PER_Visible_3_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_3_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -1921,14 +1921,14 @@ asn_enc_rval_t
 Not_PER_Visible_3_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_3_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_3_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Not_PER_Visible_3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Not_PER_Visible_3_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_3_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -1936,14 +1936,14 @@ asn_enc_rval_t
 Not_PER_Visible_3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Not_PER_Visible_3_inherit_TYPE_descriptor(td);
+	Not_PER_Visible_3_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Not-PER-Visible-3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Not_PER_Visible_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_3_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_3 = {
@@ -1957,12 +1957,12 @@ asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_3 = {
 	Not_PER_Visible_3_decode_xer,
 	Not_PER_Visible_3_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Not_PER_Visible_3_tags,
-	sizeof(asn_DEF_Not_PER_Visible_3_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_3_tags[0]), /* 1 */
-	asn_DEF_Not_PER_Visible_3_tags,	/* Same as above */
-	sizeof(asn_DEF_Not_PER_Visible_3_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_3_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_3_0_tags,
+	sizeof(asn_DEF_Not_PER_Visible_3_0_tags)
+		/sizeof(asn_DEF_Not_PER_Visible_3_0_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_3_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_3_0_tags)
+		/sizeof(asn_DEF_Not_PER_Visible_3_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2038,7 +2038,7 @@ SIZE_but_not_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-SIZE_but_not_FROM_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+SIZE_but_not_FROM_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_PER_Visible.free_struct;
 	td->print_struct   = asn_DEF_PER_Visible.print_struct;
 	td->ber_decoder    = asn_DEF_PER_Visible.ber_decoder;
@@ -2053,21 +2053,21 @@ SIZE_but_not_FROM_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 SIZE_but_not_FROM_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	SIZE_but_not_FROM_inherit_TYPE_descriptor(td);
+	SIZE_but_not_FROM_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 SIZE_but_not_FROM_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	SIZE_but_not_FROM_inherit_TYPE_descriptor(td);
+	SIZE_but_not_FROM_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 SIZE_but_not_FROM_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	SIZE_but_not_FROM_inherit_TYPE_descriptor(td);
+	SIZE_but_not_FROM_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -2075,14 +2075,14 @@ asn_enc_rval_t
 SIZE_but_not_FROM_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	SIZE_but_not_FROM_inherit_TYPE_descriptor(td);
+	SIZE_but_not_FROM_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 SIZE_but_not_FROM_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	SIZE_but_not_FROM_inherit_TYPE_descriptor(td);
+	SIZE_but_not_FROM_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -2090,14 +2090,14 @@ asn_enc_rval_t
 SIZE_but_not_FROM_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	SIZE_but_not_FROM_inherit_TYPE_descriptor(td);
+	SIZE_but_not_FROM_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [SIZE-but-not-FROM] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_SIZE_but_not_FROM_tags[] = {
+static ber_tlv_tag_t asn_DEF_SIZE_but_not_FROM_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_SIZE_but_not_FROM = {
@@ -2111,12 +2111,12 @@ asn_TYPE_descriptor_t asn_DEF_SIZE_but_not_FROM = {
 	SIZE_but_not_FROM_decode_xer,
 	SIZE_but_not_FROM_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SIZE_but_not_FROM_tags,
-	sizeof(asn_DEF_SIZE_but_not_FROM_tags)
-		/sizeof(asn_DEF_SIZE_but_not_FROM_tags[0]), /* 1 */
-	asn_DEF_SIZE_but_not_FROM_tags,	/* Same as above */
-	sizeof(asn_DEF_SIZE_but_not_FROM_tags)
-		/sizeof(asn_DEF_SIZE_but_not_FROM_tags[0]), /* 1 */
+	asn_DEF_SIZE_but_not_FROM_0_tags,
+	sizeof(asn_DEF_SIZE_but_not_FROM_0_tags)
+		/sizeof(asn_DEF_SIZE_but_not_FROM_0_tags[0]), /* 1 */
+	asn_DEF_SIZE_but_not_FROM_0_tags,	/* Same as above */
+	sizeof(asn_DEF_SIZE_but_not_FROM_0_tags)
+		/sizeof(asn_DEF_SIZE_but_not_FROM_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2192,7 +2192,7 @@ SIZE_and_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-SIZE_and_FROM_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+SIZE_and_FROM_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_PER_Visible.free_struct;
 	td->print_struct   = asn_DEF_PER_Visible.print_struct;
 	td->ber_decoder    = asn_DEF_PER_Visible.ber_decoder;
@@ -2207,21 +2207,21 @@ SIZE_and_FROM_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 SIZE_and_FROM_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	SIZE_and_FROM_inherit_TYPE_descriptor(td);
+	SIZE_and_FROM_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 SIZE_and_FROM_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	SIZE_and_FROM_inherit_TYPE_descriptor(td);
+	SIZE_and_FROM_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 SIZE_and_FROM_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	SIZE_and_FROM_inherit_TYPE_descriptor(td);
+	SIZE_and_FROM_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -2229,14 +2229,14 @@ asn_enc_rval_t
 SIZE_and_FROM_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	SIZE_and_FROM_inherit_TYPE_descriptor(td);
+	SIZE_and_FROM_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 SIZE_and_FROM_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	SIZE_and_FROM_inherit_TYPE_descriptor(td);
+	SIZE_and_FROM_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -2244,14 +2244,14 @@ asn_enc_rval_t
 SIZE_and_FROM_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	SIZE_and_FROM_inherit_TYPE_descriptor(td);
+	SIZE_and_FROM_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [SIZE-and-FROM] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_SIZE_and_FROM_tags[] = {
+static ber_tlv_tag_t asn_DEF_SIZE_and_FROM_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_SIZE_and_FROM = {
@@ -2265,12 +2265,12 @@ asn_TYPE_descriptor_t asn_DEF_SIZE_and_FROM = {
 	SIZE_and_FROM_decode_xer,
 	SIZE_and_FROM_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SIZE_and_FROM_tags,
-	sizeof(asn_DEF_SIZE_and_FROM_tags)
-		/sizeof(asn_DEF_SIZE_and_FROM_tags[0]), /* 1 */
-	asn_DEF_SIZE_and_FROM_tags,	/* Same as above */
-	sizeof(asn_DEF_SIZE_and_FROM_tags)
-		/sizeof(asn_DEF_SIZE_and_FROM_tags[0]), /* 1 */
+	asn_DEF_SIZE_and_FROM_0_tags,
+	sizeof(asn_DEF_SIZE_and_FROM_0_tags)
+		/sizeof(asn_DEF_SIZE_and_FROM_0_tags[0]), /* 1 */
+	asn_DEF_SIZE_and_FROM_0_tags,	/* Same as above */
+	sizeof(asn_DEF_SIZE_and_FROM_0_tags)
+		/sizeof(asn_DEF_SIZE_and_FROM_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2343,7 +2343,7 @@ Neither_SIZE_nor_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Neither_SIZE_nor_FROM_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_PER_Visible.free_struct;
 	td->print_struct   = asn_DEF_PER_Visible.print_struct;
 	td->ber_decoder    = asn_DEF_PER_Visible.ber_decoder;
@@ -2358,21 +2358,21 @@ Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Neither_SIZE_nor_FROM_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td);
+	Neither_SIZE_nor_FROM_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Neither_SIZE_nor_FROM_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td);
+	Neither_SIZE_nor_FROM_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Neither_SIZE_nor_FROM_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td);
+	Neither_SIZE_nor_FROM_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -2380,14 +2380,14 @@ asn_enc_rval_t
 Neither_SIZE_nor_FROM_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td);
+	Neither_SIZE_nor_FROM_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Neither_SIZE_nor_FROM_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td);
+	Neither_SIZE_nor_FROM_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -2395,14 +2395,14 @@ asn_enc_rval_t
 Neither_SIZE_nor_FROM_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td);
+	Neither_SIZE_nor_FROM_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Neither-SIZE-nor-FROM] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Neither_SIZE_nor_FROM_tags[] = {
+static ber_tlv_tag_t asn_DEF_Neither_SIZE_nor_FROM_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Neither_SIZE_nor_FROM = {
@@ -2416,12 +2416,12 @@ asn_TYPE_descriptor_t asn_DEF_Neither_SIZE_nor_FROM = {
 	Neither_SIZE_nor_FROM_decode_xer,
 	Neither_SIZE_nor_FROM_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Neither_SIZE_nor_FROM_tags,
-	sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags)
-		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags[0]), /* 1 */
-	asn_DEF_Neither_SIZE_nor_FROM_tags,	/* Same as above */
-	sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags)
-		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags[0]), /* 1 */
+	asn_DEF_Neither_SIZE_nor_FROM_0_tags,
+	sizeof(asn_DEF_Neither_SIZE_nor_FROM_0_tags)
+		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_0_tags[0]), /* 1 */
+	asn_DEF_Neither_SIZE_nor_FROM_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Neither_SIZE_nor_FROM_0_tags)
+		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2488,7 +2488,7 @@ Utf8_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Utf8_4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Utf8_4_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_UTF8String.free_struct;
 	td->print_struct   = asn_DEF_UTF8String.print_struct;
 	td->ber_decoder    = asn_DEF_UTF8String.ber_decoder;
@@ -2503,21 +2503,21 @@ Utf8_4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Utf8_4_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Utf8_4_inherit_TYPE_descriptor(td);
+	Utf8_4_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Utf8_4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_4_inherit_TYPE_descriptor(td);
+	Utf8_4_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Utf8_4_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Utf8_4_inherit_TYPE_descriptor(td);
+	Utf8_4_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -2525,14 +2525,14 @@ asn_enc_rval_t
 Utf8_4_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_4_inherit_TYPE_descriptor(td);
+	Utf8_4_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Utf8_4_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Utf8_4_inherit_TYPE_descriptor(td);
+	Utf8_4_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -2540,14 +2540,14 @@ asn_enc_rval_t
 Utf8_4_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_4_inherit_TYPE_descriptor(td);
+	Utf8_4_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Utf8-4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Utf8_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_Utf8_4_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Utf8_4 = {
@@ -2561,12 +2561,12 @@ asn_TYPE_descriptor_t asn_DEF_Utf8_4 = {
 	Utf8_4_decode_xer,
 	Utf8_4_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Utf8_4_tags,
-	sizeof(asn_DEF_Utf8_4_tags)
-		/sizeof(asn_DEF_Utf8_4_tags[0]), /* 1 */
-	asn_DEF_Utf8_4_tags,	/* Same as above */
-	sizeof(asn_DEF_Utf8_4_tags)
-		/sizeof(asn_DEF_Utf8_4_tags[0]), /* 1 */
+	asn_DEF_Utf8_4_0_tags,
+	sizeof(asn_DEF_Utf8_4_0_tags)
+		/sizeof(asn_DEF_Utf8_4_0_tags[0]), /* 1 */
+	asn_DEF_Utf8_4_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Utf8_4_0_tags)
+		/sizeof(asn_DEF_Utf8_4_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2661,7 +2661,7 @@ Utf8_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Utf8_3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Utf8_3_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Utf8_2.free_struct;
 	td->print_struct   = asn_DEF_Utf8_2.print_struct;
 	td->ber_decoder    = asn_DEF_Utf8_2.ber_decoder;
@@ -2676,21 +2676,21 @@ Utf8_3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Utf8_3_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Utf8_3_inherit_TYPE_descriptor(td);
+	Utf8_3_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Utf8_3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_3_inherit_TYPE_descriptor(td);
+	Utf8_3_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Utf8_3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Utf8_3_inherit_TYPE_descriptor(td);
+	Utf8_3_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -2698,14 +2698,14 @@ asn_enc_rval_t
 Utf8_3_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_3_inherit_TYPE_descriptor(td);
+	Utf8_3_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Utf8_3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Utf8_3_inherit_TYPE_descriptor(td);
+	Utf8_3_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -2713,14 +2713,14 @@ asn_enc_rval_t
 Utf8_3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_3_inherit_TYPE_descriptor(td);
+	Utf8_3_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Utf8-3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Utf8_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_Utf8_3_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Utf8_3 = {
@@ -2734,12 +2734,12 @@ asn_TYPE_descriptor_t asn_DEF_Utf8_3 = {
 	Utf8_3_decode_xer,
 	Utf8_3_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Utf8_3_tags,
-	sizeof(asn_DEF_Utf8_3_tags)
-		/sizeof(asn_DEF_Utf8_3_tags[0]), /* 1 */
-	asn_DEF_Utf8_3_tags,	/* Same as above */
-	sizeof(asn_DEF_Utf8_3_tags)
-		/sizeof(asn_DEF_Utf8_3_tags[0]), /* 1 */
+	asn_DEF_Utf8_3_0_tags,
+	sizeof(asn_DEF_Utf8_3_0_tags)
+		/sizeof(asn_DEF_Utf8_3_0_tags[0]), /* 1 */
+	asn_DEF_Utf8_3_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Utf8_3_0_tags)
+		/sizeof(asn_DEF_Utf8_3_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2804,7 +2804,7 @@ Utf8_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Utf8_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Utf8_2_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Utf8_1.free_struct;
 	td->print_struct   = asn_DEF_Utf8_1.print_struct;
 	td->ber_decoder    = asn_DEF_Utf8_1.ber_decoder;
@@ -2819,21 +2819,21 @@ Utf8_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Utf8_2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Utf8_2_inherit_TYPE_descriptor(td);
+	Utf8_2_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Utf8_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_2_inherit_TYPE_descriptor(td);
+	Utf8_2_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Utf8_2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Utf8_2_inherit_TYPE_descriptor(td);
+	Utf8_2_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -2841,14 +2841,14 @@ asn_enc_rval_t
 Utf8_2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_2_inherit_TYPE_descriptor(td);
+	Utf8_2_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Utf8_2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Utf8_2_inherit_TYPE_descriptor(td);
+	Utf8_2_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -2856,14 +2856,14 @@ asn_enc_rval_t
 Utf8_2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Utf8_2_inherit_TYPE_descriptor(td);
+	Utf8_2_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Utf8-2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Utf8_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Utf8_2_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Utf8_2 = {
@@ -2877,12 +2877,12 @@ asn_TYPE_descriptor_t asn_DEF_Utf8_2 = {
 	Utf8_2_decode_xer,
 	Utf8_2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Utf8_2_tags,
-	sizeof(asn_DEF_Utf8_2_tags)
-		/sizeof(asn_DEF_Utf8_2_tags[0]), /* 1 */
-	asn_DEF_Utf8_2_tags,	/* Same as above */
-	sizeof(asn_DEF_Utf8_2_tags)
-		/sizeof(asn_DEF_Utf8_2_tags[0]), /* 1 */
+	asn_DEF_Utf8_2_0_tags,
+	sizeof(asn_DEF_Utf8_2_0_tags)
+		/sizeof(asn_DEF_Utf8_2_0_tags[0]), /* 1 */
+	asn_DEF_Utf8_2_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Utf8_2_0_tags)
+		/sizeof(asn_DEF_Utf8_2_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -3008,7 +3008,7 @@ Identifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-Identifier_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Identifier_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_VisibleString.free_struct;
 	td->print_struct   = asn_DEF_VisibleString.print_struct;
 	td->ber_decoder    = asn_DEF_VisibleString.ber_decoder;
@@ -3023,21 +3023,21 @@ Identifier_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 Identifier_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	Identifier_inherit_TYPE_descriptor(td);
+	Identifier_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 Identifier_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	Identifier_inherit_TYPE_descriptor(td);
+	Identifier_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 Identifier_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	Identifier_inherit_TYPE_descriptor(td);
+	Identifier_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -3045,14 +3045,14 @@ asn_enc_rval_t
 Identifier_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Identifier_inherit_TYPE_descriptor(td);
+	Identifier_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 Identifier_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	Identifier_inherit_TYPE_descriptor(td);
+	Identifier_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -3060,14 +3060,14 @@ asn_enc_rval_t
 Identifier_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	Identifier_inherit_TYPE_descriptor(td);
+	Identifier_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [Identifier] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Identifier_tags[] = {
+static ber_tlv_tag_t asn_DEF_Identifier_0_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (26 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Identifier = {
@@ -3081,12 +3081,12 @@ asn_TYPE_descriptor_t asn_DEF_Identifier = {
 	Identifier_decode_xer,
 	Identifier_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Identifier_tags,
-	sizeof(asn_DEF_Identifier_tags)
-		/sizeof(asn_DEF_Identifier_tags[0]), /* 1 */
-	asn_DEF_Identifier_tags,	/* Same as above */
-	sizeof(asn_DEF_Identifier_tags)
-		/sizeof(asn_DEF_Identifier_tags[0]), /* 1 */
+	asn_DEF_Identifier_0_tags,
+	sizeof(asn_DEF_Identifier_0_tags)
+		/sizeof(asn_DEF_Identifier_0_tags[0]), /* 1 */
+	asn_DEF_Identifier_0_tags,	/* Same as above */
+	sizeof(asn_DEF_Identifier_0_tags)
+		/sizeof(asn_DEF_Identifier_0_tags[0]), /* 1 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
diff --git a/tests/59-choice-extended-OK.asn1.-P b/tests/59-choice-extended-OK.asn1.-P
index e2a37186..5de40958 100644
--- a/tests/59-choice-extended-OK.asn1.-P
+++ b/tests/59-choice-extended-OK.asn1.-P
@@ -39,7 +39,7 @@ typedef struct Choice {
 
 /*** <<< STAT-DEFS [Choice] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Choice[] = {
+static asn_TYPE_member_t asn_MBR_Choice_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.a),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -62,20 +62,20 @@ static asn_TYPE_member_t asn_MBR_Choice[] = {
 		.name = "c"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Choice_tags[] = {
+static ber_tlv_tag_t asn_DEF_Choice_1_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Choice_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 15 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* b at 17 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* c at 19 */
 };
-static asn_CHOICE_specifics_t asn_DEF_Choice_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice_1_specs = {
 	sizeof(struct Choice),
 	offsetof(struct Choice, _asn_ctx),
 	offsetof(struct Choice, present),
 	sizeof(((struct Choice *)0)->present),
-	asn_DEF_Choice_tag2el,
+	asn_MAP_Choice_1_tag2el,
 	3,	/* Count of tags in the map */
 	1	/* Whether extensible */
 };
@@ -90,14 +90,14 @@ asn_TYPE_descriptor_t asn_DEF_Choice = {
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
 	CHOICE_outmost_tag,
-	asn_DEF_Choice_tags,
-	sizeof(asn_DEF_Choice_tags)
-		/sizeof(asn_DEF_Choice_tags[0]), /* 1 */
-	asn_DEF_Choice_tags,	/* Same as above */
-	sizeof(asn_DEF_Choice_tags)
-		/sizeof(asn_DEF_Choice_tags[0]), /* 1 */
-	asn_MBR_Choice,
+	asn_DEF_Choice_1_tags,
+	sizeof(asn_DEF_Choice_1_tags)
+		/sizeof(asn_DEF_Choice_1_tags[0]), /* 1 */
+	asn_DEF_Choice_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Choice_1_tags)
+		/sizeof(asn_DEF_Choice_1_tags[0]), /* 1 */
+	asn_MBR_Choice_1,
 	3,	/* Elements count */
-	&asn_DEF_Choice_specs	/* Additional specs */
+	&asn_SPC_Choice_1_specs	/* Additional specs */
 };
 
diff --git a/tests/60-any-OK.asn1.-P b/tests/60-any-OK.asn1.-P
index ea5b30f7..f52ad810 100644
--- a/tests/60-any-OK.asn1.-P
+++ b/tests/60-any-OK.asn1.-P
@@ -22,7 +22,7 @@ typedef struct T1 {
 
 /*** <<< STAT-DEFS [T1] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T1[] = {
+static asn_TYPE_member_t asn_MBR_T1_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T1, i),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -38,16 +38,16 @@ static asn_TYPE_member_t asn_MBR_T1[] = {
 		.name = "any"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T1_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 15 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_T1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T1_1_specs = {
 	sizeof(struct T1),
 	offsetof(struct T1, _asn_ctx),
-	asn_DEF_T1_tag2el,
+	asn_MAP_T1_1_tag2el,
 	1,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -63,15 +63,15 @@ asn_TYPE_descriptor_t asn_DEF_T1 = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T1_tags,
-	sizeof(asn_DEF_T1_tags)
-		/sizeof(asn_DEF_T1_tags[0]), /* 1 */
-	asn_DEF_T1_tags,	/* Same as above */
-	sizeof(asn_DEF_T1_tags)
-		/sizeof(asn_DEF_T1_tags[0]), /* 1 */
-	asn_MBR_T1,
+	asn_DEF_T1_1_tags,
+	sizeof(asn_DEF_T1_1_tags)
+		/sizeof(asn_DEF_T1_1_tags[0]), /* 1 */
+	asn_DEF_T1_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T1_1_tags)
+		/sizeof(asn_DEF_T1_1_tags[0]), /* 1 */
+	asn_MBR_T1_1,
 	2,	/* Elements count */
-	&asn_DEF_T1_specs	/* Additional specs */
+	&asn_SPC_T1_1_specs	/* Additional specs */
 };
 
 
@@ -98,7 +98,7 @@ typedef struct T2 {
 
 /*** <<< STAT-DEFS [T2] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T2[] = {
+static asn_TYPE_member_t asn_MBR_T2_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T2, i),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -114,17 +114,17 @@ static asn_TYPE_member_t asn_MBR_T2[] = {
 		.name = "any"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T2_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T2_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* i at 20 */
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, 0, 0 } /* any at 21 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_T2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T2_1_specs = {
 	sizeof(struct T2),
 	offsetof(struct T2, _asn_ctx),
-	asn_DEF_T2_tag2el,
+	asn_MAP_T2_1_tag2el,
 	2,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -140,14 +140,14 @@ asn_TYPE_descriptor_t asn_DEF_T2 = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T2_tags,
-	sizeof(asn_DEF_T2_tags)
-		/sizeof(asn_DEF_T2_tags[0]), /* 1 */
-	asn_DEF_T2_tags,	/* Same as above */
-	sizeof(asn_DEF_T2_tags)
-		/sizeof(asn_DEF_T2_tags[0]), /* 1 */
-	asn_MBR_T2,
+	asn_DEF_T2_1_tags,
+	sizeof(asn_DEF_T2_1_tags)
+		/sizeof(asn_DEF_T2_1_tags[0]), /* 1 */
+	asn_DEF_T2_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T2_1_tags)
+		/sizeof(asn_DEF_T2_1_tags[0]), /* 1 */
+	asn_MBR_T2_1,
 	2,	/* Elements count */
-	&asn_DEF_T2_specs	/* Additional specs */
+	&asn_SPC_T2_1_specs	/* Additional specs */
 };
 
diff --git a/tests/65-multi-tag-OK.asn1.-P b/tests/65-multi-tag-OK.asn1.-P
index d9acecf6..39a145bf 100644
--- a/tests/65-multi-tag-OK.asn1.-P
+++ b/tests/65-multi-tag-OK.asn1.-P
@@ -34,7 +34,7 @@ T1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T1_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T2.free_struct;
 	td->print_struct   = asn_DEF_T2.print_struct;
 	td->ber_decoder    = asn_DEF_T2.ber_decoder;
@@ -49,21 +49,21 @@ T1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T1_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -71,14 +71,14 @@ asn_enc_rval_t
 T1_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -86,20 +86,20 @@ asn_enc_rval_t
 T1_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2))
 };
-static ber_tlv_tag_t asn_DEF_T1_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_0_all_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
@@ -118,12 +118,12 @@ asn_TYPE_descriptor_t asn_DEF_T1 = {
 	T1_decode_xer,
 	T1_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T1_tags,
-	sizeof(asn_DEF_T1_tags)
-		/sizeof(asn_DEF_T1_tags[0]), /* 4 */
-	asn_DEF_T1_all_tags,
-	sizeof(asn_DEF_T1_all_tags)
-		/sizeof(asn_DEF_T1_all_tags[0]), /* 6 */
+	asn_DEF_T1_0_tags,
+	sizeof(asn_DEF_T1_0_tags)
+		/sizeof(asn_DEF_T1_0_tags[0]), /* 4 */
+	asn_DEF_T1_0_all_tags,
+	sizeof(asn_DEF_T1_0_all_tags)
+		/sizeof(asn_DEF_T1_0_all_tags[0]), /* 6 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -164,7 +164,7 @@ T2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T2_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T3.free_struct;
 	td->print_struct   = asn_DEF_T3.print_struct;
 	td->ber_decoder    = asn_DEF_T3.ber_decoder;
@@ -179,21 +179,21 @@ T2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -201,14 +201,14 @@ asn_enc_rval_t
 T2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -216,19 +216,19 @@ asn_enc_rval_t
 T2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T2_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2))
 };
-static ber_tlv_tag_t asn_DEF_T2_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_0_all_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
@@ -246,12 +246,12 @@ asn_TYPE_descriptor_t asn_DEF_T2 = {
 	T2_decode_xer,
 	T2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T2_tags,
-	sizeof(asn_DEF_T2_tags)
-		/sizeof(asn_DEF_T2_tags[0]), /* 3 */
-	asn_DEF_T2_all_tags,
-	sizeof(asn_DEF_T2_all_tags)
-		/sizeof(asn_DEF_T2_all_tags[0]), /* 5 */
+	asn_DEF_T2_0_tags,
+	sizeof(asn_DEF_T2_0_tags)
+		/sizeof(asn_DEF_T2_0_tags[0]), /* 3 */
+	asn_DEF_T2_0_all_tags,
+	sizeof(asn_DEF_T2_0_all_tags)
+		/sizeof(asn_DEF_T2_0_all_tags[0]), /* 5 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -292,7 +292,7 @@ T3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T3_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T4.free_struct;
 	td->print_struct   = asn_DEF_T4.print_struct;
 	td->ber_decoder    = asn_DEF_T4.ber_decoder;
@@ -307,21 +307,21 @@ T3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T3_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -329,14 +329,14 @@ asn_enc_rval_t
 T3_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -344,18 +344,18 @@ asn_enc_rval_t
 T3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T3_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2))
 };
-static ber_tlv_tag_t asn_DEF_T3_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_0_all_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
@@ -372,12 +372,12 @@ asn_TYPE_descriptor_t asn_DEF_T3 = {
 	T3_decode_xer,
 	T3_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T3_tags,
-	sizeof(asn_DEF_T3_tags)
-		/sizeof(asn_DEF_T3_tags[0]), /* 2 */
-	asn_DEF_T3_all_tags,
-	sizeof(asn_DEF_T3_all_tags)
-		/sizeof(asn_DEF_T3_all_tags[0]), /* 4 */
+	asn_DEF_T3_0_tags,
+	sizeof(asn_DEF_T3_0_tags)
+		/sizeof(asn_DEF_T3_0_tags[0]), /* 2 */
+	asn_DEF_T3_0_all_tags,
+	sizeof(asn_DEF_T3_0_all_tags)
+		/sizeof(asn_DEF_T3_0_all_tags[0]), /* 4 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -418,7 +418,7 @@ T4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T4_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T5.free_struct;
 	td->print_struct   = asn_DEF_T5.print_struct;
 	td->ber_decoder    = asn_DEF_T5.ber_decoder;
@@ -433,21 +433,21 @@ T4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T4_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T4_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -455,14 +455,14 @@ asn_enc_rval_t
 T4_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T4_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -470,14 +470,14 @@ asn_enc_rval_t
 T4_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T4_tags[] = {
+static ber_tlv_tag_t asn_DEF_T4_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
@@ -493,12 +493,12 @@ asn_TYPE_descriptor_t asn_DEF_T4 = {
 	T4_decode_xer,
 	T4_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T4_tags,
-	sizeof(asn_DEF_T4_tags)
-		/sizeof(asn_DEF_T4_tags[0]) - 1, /* 2 */
-	asn_DEF_T4_tags,	/* Same as above */
-	sizeof(asn_DEF_T4_tags)
-		/sizeof(asn_DEF_T4_tags[0]), /* 3 */
+	asn_DEF_T4_0_tags,
+	sizeof(asn_DEF_T4_0_tags)
+		/sizeof(asn_DEF_T4_0_tags[0]) - 1, /* 2 */
+	asn_DEF_T4_0_tags,	/* Same as above */
+	sizeof(asn_DEF_T4_0_tags)
+		/sizeof(asn_DEF_T4_0_tags[0]), /* 3 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -539,7 +539,7 @@ T5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T5_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T5_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T6.free_struct;
 	td->print_struct   = asn_DEF_T6.print_struct;
 	td->ber_decoder    = asn_DEF_T6.ber_decoder;
@@ -554,21 +554,21 @@ T5_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T5_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T5_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -576,14 +576,14 @@ asn_enc_rval_t
 T5_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T5_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -591,14 +591,14 @@ asn_enc_rval_t
 T5_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T5_tags[] = {
+static ber_tlv_tag_t asn_DEF_T5_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 };
@@ -613,12 +613,12 @@ asn_TYPE_descriptor_t asn_DEF_T5 = {
 	T5_decode_xer,
 	T5_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T5_tags,
-	sizeof(asn_DEF_T5_tags)
-		/sizeof(asn_DEF_T5_tags[0]) - 1, /* 1 */
-	asn_DEF_T5_tags,	/* Same as above */
-	sizeof(asn_DEF_T5_tags)
-		/sizeof(asn_DEF_T5_tags[0]), /* 2 */
+	asn_DEF_T5_0_tags,
+	sizeof(asn_DEF_T5_0_tags)
+		/sizeof(asn_DEF_T5_0_tags[0]) - 1, /* 1 */
+	asn_DEF_T5_0_tags,	/* Same as above */
+	sizeof(asn_DEF_T5_0_tags)
+		/sizeof(asn_DEF_T5_0_tags[0]), /* 2 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -678,7 +678,7 @@ T_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Ts.free_struct;
 	td->print_struct   = asn_DEF_Ts.print_struct;
 	td->ber_decoder    = asn_DEF_Ts.ber_decoder;
@@ -693,21 +693,21 @@ T_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -715,14 +715,14 @@ asn_enc_rval_t
 T_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -730,14 +730,14 @@ asn_enc_rval_t
 T_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
@@ -753,12 +753,12 @@ asn_TYPE_descriptor_t asn_DEF_T = {
 	T_decode_xer,
 	T_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_tags,
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]) - 2, /* 1 */
-	asn_DEF_T_tags,	/* Same as above */
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 3 */
+	asn_DEF_T_0_tags,
+	sizeof(asn_DEF_T_0_tags)
+		/sizeof(asn_DEF_T_0_tags[0]) - 2, /* 1 */
+	asn_DEF_T_0_tags,	/* Same as above */
+	sizeof(asn_DEF_T_0_tags)
+		/sizeof(asn_DEF_T_0_tags[0]), /* 3 */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -788,7 +788,7 @@ typedef struct Ts {
 
 /*** <<< STAT-DEFS [Ts] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Ts[] = {
+static asn_TYPE_member_t asn_MBR_Ts_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Ts, m1),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -811,19 +811,19 @@ static asn_TYPE_member_t asn_MBR_Ts[] = {
 		.name = "m3"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Ts_tags[] = {
+static ber_tlv_tag_t asn_DEF_Ts_1_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Ts_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Ts_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* m1 at 24 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* m2 at 25 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 } /* m3 at 27 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_Ts_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Ts_1_specs = {
 	sizeof(struct Ts),
 	offsetof(struct Ts, _asn_ctx),
-	asn_DEF_Ts_tag2el,
+	asn_MAP_Ts_1_tag2el,
 	3,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -839,14 +839,14 @@ asn_TYPE_descriptor_t asn_DEF_Ts = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Ts_tags,
-	sizeof(asn_DEF_Ts_tags)
-		/sizeof(asn_DEF_Ts_tags[0]) - 1, /* 1 */
-	asn_DEF_Ts_tags,	/* Same as above */
-	sizeof(asn_DEF_Ts_tags)
-		/sizeof(asn_DEF_Ts_tags[0]), /* 2 */
-	asn_MBR_Ts,
+	asn_DEF_Ts_1_tags,
+	sizeof(asn_DEF_Ts_1_tags)
+		/sizeof(asn_DEF_Ts_1_tags[0]) - 1, /* 1 */
+	asn_DEF_Ts_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Ts_1_tags)
+		/sizeof(asn_DEF_Ts_1_tags[0]), /* 2 */
+	asn_MBR_Ts_1,
 	3,	/* Elements count */
-	&asn_DEF_Ts_specs	/* Additional specs */
+	&asn_SPC_Ts_1_specs	/* Additional specs */
 };
 
diff --git a/tests/65-multi-tag-OK.asn1.-Pfnative-types b/tests/65-multi-tag-OK.asn1.-Pfnative-types
index 8e258484..30e0173d 100644
--- a/tests/65-multi-tag-OK.asn1.-Pfnative-types
+++ b/tests/65-multi-tag-OK.asn1.-Pfnative-types
@@ -34,7 +34,7 @@ T1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T1_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T2.free_struct;
 	td->print_struct   = asn_DEF_T2.print_struct;
 	td->ber_decoder    = asn_DEF_T2.ber_decoder;
@@ -49,21 +49,21 @@ T1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T1_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -71,14 +71,14 @@ asn_enc_rval_t
 T1_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -86,20 +86,20 @@ asn_enc_rval_t
 T1_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T1_inherit_TYPE_descriptor(td);
+	T1_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2))
 };
-static ber_tlv_tag_t asn_DEF_T1_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_0_all_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
@@ -118,12 +118,12 @@ asn_TYPE_descriptor_t asn_DEF_T1 = {
 	T1_decode_xer,
 	T1_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T1_tags,
-	sizeof(asn_DEF_T1_tags)
-		/sizeof(asn_DEF_T1_tags[0]), /* 4 */
-	asn_DEF_T1_all_tags,
-	sizeof(asn_DEF_T1_all_tags)
-		/sizeof(asn_DEF_T1_all_tags[0]), /* 6 */
+	asn_DEF_T1_0_tags,
+	sizeof(asn_DEF_T1_0_tags)
+		/sizeof(asn_DEF_T1_0_tags[0]), /* 4 */
+	asn_DEF_T1_0_all_tags,
+	sizeof(asn_DEF_T1_0_all_tags)
+		/sizeof(asn_DEF_T1_0_all_tags[0]), /* 6 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -164,7 +164,7 @@ T2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T2_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T3.free_struct;
 	td->print_struct   = asn_DEF_T3.print_struct;
 	td->ber_decoder    = asn_DEF_T3.ber_decoder;
@@ -179,21 +179,21 @@ T2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -201,14 +201,14 @@ asn_enc_rval_t
 T2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -216,19 +216,19 @@ asn_enc_rval_t
 T2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T2_inherit_TYPE_descriptor(td);
+	T2_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T2_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2))
 };
-static ber_tlv_tag_t asn_DEF_T2_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_0_all_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
@@ -246,12 +246,12 @@ asn_TYPE_descriptor_t asn_DEF_T2 = {
 	T2_decode_xer,
 	T2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T2_tags,
-	sizeof(asn_DEF_T2_tags)
-		/sizeof(asn_DEF_T2_tags[0]), /* 3 */
-	asn_DEF_T2_all_tags,
-	sizeof(asn_DEF_T2_all_tags)
-		/sizeof(asn_DEF_T2_all_tags[0]), /* 5 */
+	asn_DEF_T2_0_tags,
+	sizeof(asn_DEF_T2_0_tags)
+		/sizeof(asn_DEF_T2_0_tags[0]), /* 3 */
+	asn_DEF_T2_0_all_tags,
+	sizeof(asn_DEF_T2_0_all_tags)
+		/sizeof(asn_DEF_T2_0_all_tags[0]), /* 5 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -292,7 +292,7 @@ T3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T3_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T4.free_struct;
 	td->print_struct   = asn_DEF_T4.print_struct;
 	td->ber_decoder    = asn_DEF_T4.ber_decoder;
@@ -307,21 +307,21 @@ T3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T3_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -329,14 +329,14 @@ asn_enc_rval_t
 T3_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -344,18 +344,18 @@ asn_enc_rval_t
 T3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T3_inherit_TYPE_descriptor(td);
+	T3_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T3_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2))
 };
-static ber_tlv_tag_t asn_DEF_T3_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_0_all_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
@@ -372,12 +372,12 @@ asn_TYPE_descriptor_t asn_DEF_T3 = {
 	T3_decode_xer,
 	T3_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T3_tags,
-	sizeof(asn_DEF_T3_tags)
-		/sizeof(asn_DEF_T3_tags[0]), /* 2 */
-	asn_DEF_T3_all_tags,
-	sizeof(asn_DEF_T3_all_tags)
-		/sizeof(asn_DEF_T3_all_tags[0]), /* 4 */
+	asn_DEF_T3_0_tags,
+	sizeof(asn_DEF_T3_0_tags)
+		/sizeof(asn_DEF_T3_0_tags[0]), /* 2 */
+	asn_DEF_T3_0_all_tags,
+	sizeof(asn_DEF_T3_0_all_tags)
+		/sizeof(asn_DEF_T3_0_all_tags[0]), /* 4 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -418,7 +418,7 @@ T4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T4_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T5.free_struct;
 	td->print_struct   = asn_DEF_T5.print_struct;
 	td->ber_decoder    = asn_DEF_T5.ber_decoder;
@@ -433,21 +433,21 @@ T4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T4_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T4_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -455,14 +455,14 @@ asn_enc_rval_t
 T4_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T4_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -470,14 +470,14 @@ asn_enc_rval_t
 T4_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T4_inherit_TYPE_descriptor(td);
+	T4_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T4_tags[] = {
+static ber_tlv_tag_t asn_DEF_T4_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
@@ -493,12 +493,12 @@ asn_TYPE_descriptor_t asn_DEF_T4 = {
 	T4_decode_xer,
 	T4_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T4_tags,
-	sizeof(asn_DEF_T4_tags)
-		/sizeof(asn_DEF_T4_tags[0]) - 1, /* 2 */
-	asn_DEF_T4_tags,	/* Same as above */
-	sizeof(asn_DEF_T4_tags)
-		/sizeof(asn_DEF_T4_tags[0]), /* 3 */
+	asn_DEF_T4_0_tags,
+	sizeof(asn_DEF_T4_0_tags)
+		/sizeof(asn_DEF_T4_0_tags[0]) - 1, /* 2 */
+	asn_DEF_T4_0_tags,	/* Same as above */
+	sizeof(asn_DEF_T4_0_tags)
+		/sizeof(asn_DEF_T4_0_tags[0]), /* 3 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -539,7 +539,7 @@ T5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T5_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T5_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_T6.free_struct;
 	td->print_struct   = asn_DEF_T6.print_struct;
 	td->ber_decoder    = asn_DEF_T6.ber_decoder;
@@ -554,21 +554,21 @@ T5_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T5_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T5_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -576,14 +576,14 @@ asn_enc_rval_t
 T5_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T5_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -591,14 +591,14 @@ asn_enc_rval_t
 T5_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T5_inherit_TYPE_descriptor(td);
+	T5_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T5_tags[] = {
+static ber_tlv_tag_t asn_DEF_T5_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 };
@@ -613,12 +613,12 @@ asn_TYPE_descriptor_t asn_DEF_T5 = {
 	T5_decode_xer,
 	T5_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T5_tags,
-	sizeof(asn_DEF_T5_tags)
-		/sizeof(asn_DEF_T5_tags[0]) - 1, /* 1 */
-	asn_DEF_T5_tags,	/* Same as above */
-	sizeof(asn_DEF_T5_tags)
-		/sizeof(asn_DEF_T5_tags[0]), /* 2 */
+	asn_DEF_T5_0_tags,
+	sizeof(asn_DEF_T5_0_tags)
+		/sizeof(asn_DEF_T5_0_tags[0]) - 1, /* 1 */
+	asn_DEF_T5_0_tags,	/* Same as above */
+	sizeof(asn_DEF_T5_0_tags)
+		/sizeof(asn_DEF_T5_0_tags[0]), /* 2 */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -678,7 +678,7 @@ T_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-T_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+T_0_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_Ts.free_struct;
 	td->print_struct   = asn_DEF_Ts.print_struct;
 	td->ber_decoder    = asn_DEF_Ts.ber_decoder;
@@ -693,21 +693,21 @@ T_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 T_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 T_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 T_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -715,14 +715,14 @@ asn_enc_rval_t
 T_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 T_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -730,14 +730,14 @@ asn_enc_rval_t
 T_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	T_inherit_TYPE_descriptor(td);
+	T_0_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_0_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
@@ -753,12 +753,12 @@ asn_TYPE_descriptor_t asn_DEF_T = {
 	T_decode_xer,
 	T_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_tags,
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]) - 2, /* 1 */
-	asn_DEF_T_tags,	/* Same as above */
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 3 */
+	asn_DEF_T_0_tags,
+	sizeof(asn_DEF_T_0_tags)
+		/sizeof(asn_DEF_T_0_tags[0]) - 2, /* 1 */
+	asn_DEF_T_0_tags,	/* Same as above */
+	sizeof(asn_DEF_T_0_tags)
+		/sizeof(asn_DEF_T_0_tags[0]), /* 3 */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -788,7 +788,7 @@ typedef struct Ts {
 
 /*** <<< STAT-DEFS [Ts] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Ts[] = {
+static asn_TYPE_member_t asn_MBR_Ts_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Ts, m1),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -811,19 +811,19 @@ static asn_TYPE_member_t asn_MBR_Ts[] = {
 		.name = "m3"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Ts_tags[] = {
+static ber_tlv_tag_t asn_DEF_Ts_1_tags[] = {
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Ts_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Ts_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* m1 at 24 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* m2 at 25 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 } /* m3 at 27 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_Ts_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Ts_1_specs = {
 	sizeof(struct Ts),
 	offsetof(struct Ts, _asn_ctx),
-	asn_DEF_Ts_tag2el,
+	asn_MAP_Ts_1_tag2el,
 	3,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -839,14 +839,14 @@ asn_TYPE_descriptor_t asn_DEF_Ts = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Ts_tags,
-	sizeof(asn_DEF_Ts_tags)
-		/sizeof(asn_DEF_Ts_tags[0]) - 1, /* 1 */
-	asn_DEF_Ts_tags,	/* Same as above */
-	sizeof(asn_DEF_Ts_tags)
-		/sizeof(asn_DEF_Ts_tags[0]), /* 2 */
-	asn_MBR_Ts,
+	asn_DEF_Ts_1_tags,
+	sizeof(asn_DEF_Ts_1_tags)
+		/sizeof(asn_DEF_Ts_1_tags[0]) - 1, /* 1 */
+	asn_DEF_Ts_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Ts_1_tags)
+		/sizeof(asn_DEF_Ts_1_tags[0]), /* 2 */
+	asn_MBR_Ts_1,
 	3,	/* Elements count */
-	&asn_DEF_Ts_specs	/* Additional specs */
+	&asn_SPC_Ts_1_specs	/* Additional specs */
 };
 
diff --git a/tests/66-ref-simple-OK.asn1.-P b/tests/66-ref-simple-OK.asn1.-P
index 61c5e044..5112e534 100644
--- a/tests/66-ref-simple-OK.asn1.-P
+++ b/tests/66-ref-simple-OK.asn1.-P
@@ -21,7 +21,7 @@ typedef struct T {
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_T[] = {
+static asn_TYPE_member_t asn_MBR_T_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
 		.tag_mode = 0,
@@ -30,10 +30,10 @@ static asn_TYPE_member_t asn_MBR_T[] = {
 		.name = "named"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_T_specs = {
+static asn_SET_OF_specifics_t asn_SPC_T_1_specs = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -49,15 +49,15 @@ asn_TYPE_descriptor_t asn_DEF_T = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_tags,
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 1 */
-	asn_DEF_T_tags,	/* Same as above */
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 1 */
-	asn_MBR_T,
+	asn_DEF_T_1_tags,
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 1 */
+	asn_DEF_T_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 1 */
+	asn_MBR_T_1,
 	1,	/* Single element */
-	&asn_DEF_T_specs	/* Additional specs */
+	&asn_SPC_T_1_specs	/* Additional specs */
 };
 
 
@@ -104,7 +104,7 @@ SimpleType_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-SimpleType_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+SimpleType_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
 	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
 	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
@@ -119,21 +119,21 @@ SimpleType_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 void
 SimpleType_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	SimpleType_inherit_TYPE_descriptor(td);
+	SimpleType_1_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 int
 SimpleType_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	SimpleType_inherit_TYPE_descriptor(td);
+	SimpleType_1_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 asn_dec_rval_t
 SimpleType_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	SimpleType_inherit_TYPE_descriptor(td);
+	SimpleType_1_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
@@ -141,14 +141,14 @@ asn_enc_rval_t
 SimpleType_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	SimpleType_inherit_TYPE_descriptor(td);
+	SimpleType_1_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 asn_dec_rval_t
 SimpleType_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	SimpleType_inherit_TYPE_descriptor(td);
+	SimpleType_1_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
@@ -156,31 +156,31 @@ asn_enc_rval_t
 SimpleType_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	SimpleType_inherit_TYPE_descriptor(td);
+	SimpleType_1_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [SimpleType] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_SimpleType_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_SimpleType_1_value2enum[] = {
 	{ 0,	3,	"one" },
 	{ 1,	3,	"two" },
 	{ 2,	5,	"three" }
 };
-static unsigned int asn_MAP_SimpleType_enum2value[] = {
+static unsigned int asn_MAP_SimpleType_1_enum2value[] = {
 	0,	/* one(0) */
 	2,	/* three(2) */
 	1	/* two(1) */
 };
-static asn_INTEGER_specifics_t asn_DEF_SimpleType_specs = {
-	asn_MAP_SimpleType_value2enum,	/* "tag" => N; sorted by tag */
-	asn_MAP_SimpleType_enum2value,	/* N => "tag"; sorted by N */
+static asn_INTEGER_specifics_t asn_SPC_SimpleType_1_specs = {
+	asn_MAP_SimpleType_1_value2enum,	/* "tag" => N; sorted by tag */
+	asn_MAP_SimpleType_1_enum2value,	/* N => "tag"; sorted by N */
 	3,	/* Number of elements in the maps */
 	0,	/* Enumeration is not extensible */
 	1	/* Strict enumeration */
 };
-static ber_tlv_tag_t asn_DEF_SimpleType_tags[] = {
+static ber_tlv_tag_t asn_DEF_SimpleType_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_SimpleType = {
@@ -194,13 +194,13 @@ asn_TYPE_descriptor_t asn_DEF_SimpleType = {
 	SimpleType_decode_xer,
 	SimpleType_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SimpleType_tags,
-	sizeof(asn_DEF_SimpleType_tags)
-		/sizeof(asn_DEF_SimpleType_tags[0]), /* 1 */
-	asn_DEF_SimpleType_tags,	/* Same as above */
-	sizeof(asn_DEF_SimpleType_tags)
-		/sizeof(asn_DEF_SimpleType_tags[0]), /* 1 */
+	asn_DEF_SimpleType_1_tags,
+	sizeof(asn_DEF_SimpleType_1_tags)
+		/sizeof(asn_DEF_SimpleType_1_tags[0]), /* 1 */
+	asn_DEF_SimpleType_1_tags,	/* Same as above */
+	sizeof(asn_DEF_SimpleType_1_tags)
+		/sizeof(asn_DEF_SimpleType_1_tags[0]), /* 1 */
 	0, 0,	/* Defined elsewhere */
-	&asn_DEF_SimpleType_specs	/* Additional specs */
+	&asn_SPC_SimpleType_1_specs	/* Additional specs */
 };
 
diff --git a/tests/69-reserved-words-OK.asn1.-P b/tests/69-reserved-words-OK.asn1.-P
index a3a9f054..78d035b8 100644
--- a/tests/69-reserved-words-OK.asn1.-P
+++ b/tests/69-reserved-words-OK.asn1.-P
@@ -73,27 +73,27 @@ memb_char_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_class_tags[] = {
+static ber_tlv_tag_t asn_DEF_class_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_class_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_class_2_tag2el[] = {
 };
-static uint8_t asn_DEF_class_mmap[(0 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_class_2_mmap[(0 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	0
 };
-static asn_SET_specifics_t asn_DEF_class_specs = {
+static asn_SET_specifics_t asn_SPC_class_2_specs = {
 	sizeof(struct Class),
 	offsetof(struct Class, _asn_ctx),
 	offsetof(struct Class, _presence_map),
-	asn_DEF_class_tag2el,
+	asn_MAP_class_2_tag2el,
 	0,	/* Count of tags in the map */
-	asn_DEF_class_tag2el,	/* Same as above */
+	asn_MAP_class_2_tag2el,	/* Same as above */
 	0,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_DEF_class_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_class_2_mmap	/* Mandatory elements map */
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_class = {
+asn_TYPE_descriptor_t asn_DEF_class_2 = {
 	"class",
 	"class",
 	SET_free,
@@ -104,17 +104,17 @@ asn_TYPE_descriptor_t asn_DEF_class = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_class_tags,
-	sizeof(asn_DEF_class_tags)
-		/sizeof(asn_DEF_class_tags[0]), /* 1 */
-	asn_DEF_class_tags,	/* Same as above */
-	sizeof(asn_DEF_class_tags)
-		/sizeof(asn_DEF_class_tags[0]), /* 1 */
+	asn_DEF_class_2_tags,
+	sizeof(asn_DEF_class_2_tags)
+		/sizeof(asn_DEF_class_2_tags[0]), /* 1 */
+	asn_DEF_class_2_tags,	/* Same as above */
+	sizeof(asn_DEF_class_2_tags)
+		/sizeof(asn_DEF_class_2_tags[0]), /* 1 */
 	0, 0,	/* No members */
-	&asn_DEF_class_specs	/* Additional specs */
+	&asn_SPC_class_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_T[] = {
+static asn_TYPE_member_t asn_MBR_T_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T, Int),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
@@ -132,7 +132,7 @@ static asn_TYPE_member_t asn_MBR_T[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct T, Class),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_class,
+		.type = (void *)&asn_DEF_class_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "class"
 		},
@@ -144,19 +144,19 @@ static asn_TYPE_member_t asn_MBR_T[] = {
 		.name = "double"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_T_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* int at 15 */
     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 0 }, /* char at 16 */
     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 3, 0, 0 }, /* double at 18 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 2, 0, 0 } /* class at 17 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_T_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T_1_specs = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
-	asn_DEF_T_tag2el,
+	asn_MAP_T_1_tag2el,
 	4,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -172,14 +172,14 @@ asn_TYPE_descriptor_t asn_DEF_T = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_tags,
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 1 */
-	asn_DEF_T_tags,	/* Same as above */
-	sizeof(asn_DEF_T_tags)
-		/sizeof(asn_DEF_T_tags[0]), /* 1 */
-	asn_MBR_T,
+	asn_DEF_T_1_tags,
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 1 */
+	asn_DEF_T_1_tags,	/* Same as above */
+	sizeof(asn_DEF_T_1_tags)
+		/sizeof(asn_DEF_T_1_tags[0]), /* 1 */
+	asn_MBR_T_1,
 	4,	/* Elements count */
-	&asn_DEF_T_specs	/* Additional specs */
+	&asn_SPC_T_1_specs	/* Additional specs */
 };
 
diff --git a/tests/70-xer-test-OK.asn1.-P b/tests/70-xer-test-OK.asn1.-P
index e9eaa70a..2c356b9b 100644
--- a/tests/70-xer-test-OK.asn1.-P
+++ b/tests/70-xer-test-OK.asn1.-P
@@ -56,7 +56,7 @@ typedef struct PDU {
 
 /*** <<< STAT-DEFS [PDU] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_PDU[] = {
+static asn_TYPE_member_t asn_MBR_PDU_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.sequence),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -121,7 +121,7 @@ static asn_TYPE_member_t asn_MBR_PDU[] = {
 		.name = "seqOfZuka"
 		},
 };
-static asn_TYPE_tag2member_t asn_DEF_PDU_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_PDU_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* sequence at 19 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* set at 20 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* setOf at 21 */
@@ -132,12 +132,12 @@ static asn_TYPE_tag2member_t asn_DEF_PDU_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* setOfEnums at 26 */
     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 } /* seqOfZuka at 27 */
 };
-static asn_CHOICE_specifics_t asn_DEF_PDU_specs = {
+static asn_CHOICE_specifics_t asn_SPC_PDU_1_specs = {
 	sizeof(struct PDU),
 	offsetof(struct PDU, _asn_ctx),
 	offsetof(struct PDU, present),
 	sizeof(((struct PDU *)0)->present),
-	asn_DEF_PDU_tag2el,
+	asn_MAP_PDU_1_tag2el,
 	9,	/* Count of tags in the map */
 	1	/* Whether extensible */
 };
@@ -156,9 +156,9 @@ asn_TYPE_descriptor_t asn_DEF_PDU = {
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
-	asn_MBR_PDU,
+	asn_MBR_PDU_1,
 	9,	/* Elements count */
-	&asn_DEF_PDU_specs	/* Additional specs */
+	&asn_SPC_PDU_1_specs	/* Additional specs */
 };
 
 
@@ -191,7 +191,7 @@ typedef struct Sequence {
 
 /*** <<< STAT-DEFS [Sequence] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Sequence[] = {
+static asn_TYPE_member_t asn_MBR_Sequence_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Sequence, integer),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -221,19 +221,19 @@ static asn_TYPE_member_t asn_MBR_Sequence[] = {
 		.name = "string"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Sequence_tags[] = {
+static ber_tlv_tag_t asn_DEF_Sequence_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Sequence_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Sequence_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* integer at 32 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* sequence at 33 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* bits at 34 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* string at 35 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_Sequence_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Sequence_1_specs = {
 	sizeof(struct Sequence),
 	offsetof(struct Sequence, _asn_ctx),
-	asn_DEF_Sequence_tag2el,
+	asn_MAP_Sequence_1_tag2el,
 	4,	/* Count of tags in the map */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
@@ -249,15 +249,15 @@ asn_TYPE_descriptor_t asn_DEF_Sequence = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Sequence_tags,
-	sizeof(asn_DEF_Sequence_tags)
-		/sizeof(asn_DEF_Sequence_tags[0]), /* 1 */
-	asn_DEF_Sequence_tags,	/* Same as above */
-	sizeof(asn_DEF_Sequence_tags)
-		/sizeof(asn_DEF_Sequence_tags[0]), /* 1 */
-	asn_MBR_Sequence,
+	asn_DEF_Sequence_1_tags,
+	sizeof(asn_DEF_Sequence_1_tags)
+		/sizeof(asn_DEF_Sequence_1_tags[0]), /* 1 */
+	asn_DEF_Sequence_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Sequence_1_tags)
+		/sizeof(asn_DEF_Sequence_1_tags[0]), /* 1 */
+	asn_MBR_Sequence_1,
 	4,	/* Elements count */
-	&asn_DEF_Sequence_specs	/* Additional specs */
+	&asn_SPC_Sequence_1_specs	/* Additional specs */
 };
 
 
@@ -296,7 +296,7 @@ typedef struct Set {
 
 /*** <<< STAT-DEFS [Set] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Set[] = {
+static asn_TYPE_member_t asn_MBR_Set_1[] = {
 	{ ATF_NOFLAGS, 0, offsetof(struct Set, roid),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -312,26 +312,26 @@ static asn_TYPE_member_t asn_MBR_Set[] = {
 		.name = "opaque"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Set_tags[] = {
+static ber_tlv_tag_t asn_DEF_Set_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_Set_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Set_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* roid at 39 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* opaque at 40 */
 };
-static uint8_t asn_DEF_Set_mmap[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Set_1_mmap[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (0 << 6)
 };
-static asn_SET_specifics_t asn_DEF_Set_specs = {
+static asn_SET_specifics_t asn_SPC_Set_1_specs = {
 	sizeof(struct Set),
 	offsetof(struct Set, _asn_ctx),
 	offsetof(struct Set, _presence_map),
-	asn_DEF_Set_tag2el,
+	asn_MAP_Set_1_tag2el,
 	2,	/* Count of tags in the map */
-	asn_DEF_Set_tag2el,	/* Same as above */
+	asn_MAP_Set_1_tag2el,	/* Same as above */
 	2,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_DEF_Set_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Set_1_mmap	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Set = {
 	"Set",
@@ -344,15 +344,15 @@ asn_TYPE_descriptor_t asn_DEF_Set = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Set_tags,
-	sizeof(asn_DEF_Set_tags)
-		/sizeof(asn_DEF_Set_tags[0]), /* 1 */
-	asn_DEF_Set_tags,	/* Same as above */
-	sizeof(asn_DEF_Set_tags)
-		/sizeof(asn_DEF_Set_tags[0]), /* 1 */
-	asn_MBR_Set,
+	asn_DEF_Set_1_tags,
+	sizeof(asn_DEF_Set_1_tags)
+		/sizeof(asn_DEF_Set_1_tags[0]), /* 1 */
+	asn_DEF_Set_1_tags,	/* Same as above */
+	sizeof(asn_DEF_Set_1_tags)
+		/sizeof(asn_DEF_Set_1_tags[0]), /* 1 */
+	asn_MBR_Set_1,
 	2,	/* Elements count */
-	&asn_DEF_Set_specs	/* Additional specs */
+	&asn_SPC_Set_1_specs	/* Additional specs */
 };
 
 
@@ -392,7 +392,7 @@ typedef struct ExtensibleSet {
 
 /*** <<< STAT-DEFS [ExtensibleSet] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_ExtensibleSet[] = {
+static asn_TYPE_member_t asn_MBR_ExtensibleSet_1[] = {
 	{ ATF_POINTER, 1, offsetof(struct ExtensibleSet, string),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -401,25 +401,25 @@ static asn_TYPE_member_t asn_MBR_ExtensibleSet[] = {
 		.name = "string"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ExtensibleSet_tags[] = {
+static ber_tlv_tag_t asn_DEF_ExtensibleSet_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_ExtensibleSet_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ExtensibleSet_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* string at 44 */
 };
-static uint8_t asn_DEF_ExtensibleSet_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_ExtensibleSet_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(0 << 7)
 };
-static asn_SET_specifics_t asn_DEF_ExtensibleSet_specs = {
+static asn_SET_specifics_t asn_SPC_ExtensibleSet_1_specs = {
 	sizeof(struct ExtensibleSet),
 	offsetof(struct ExtensibleSet, _asn_ctx),
 	offsetof(struct ExtensibleSet, _presence_map),
-	asn_DEF_ExtensibleSet_tag2el,
+	asn_MAP_ExtensibleSet_1_tag2el,
 	1,	/* Count of tags in the map */
-	asn_DEF_ExtensibleSet_tag2el,	/* Same as above */
+	asn_MAP_ExtensibleSet_1_tag2el,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_DEF_ExtensibleSet_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_ExtensibleSet_1_mmap	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_ExtensibleSet = {
 	"ExtensibleSet",
@@ -432,15 +432,15 @@ asn_TYPE_descriptor_t asn_DEF_ExtensibleSet = {
 	SET_decode_xer,
 	SET_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ExtensibleSet_tags,
-	sizeof(asn_DEF_ExtensibleSet_tags)
-		/sizeof(asn_DEF_ExtensibleSet_tags[0]), /* 1 */
-	asn_DEF_ExtensibleSet_tags,	/* Same as above */
-	sizeof(asn_DEF_ExtensibleSet_tags)
-		/sizeof(asn_DEF_ExtensibleSet_tags[0]), /* 1 */
-	asn_MBR_ExtensibleSet,
+	asn_DEF_ExtensibleSet_1_tags,
+	sizeof(asn_DEF_ExtensibleSet_1_tags)
+		/sizeof(asn_DEF_ExtensibleSet_1_tags[0]), /* 1 */
+	asn_DEF_ExtensibleSet_1_tags,	/* Same as above */
+	sizeof(asn_DEF_ExtensibleSet_1_tags)
+		/sizeof(asn_DEF_ExtensibleSet_1_tags[0]), /* 1 */
+	asn_MBR_ExtensibleSet_1,
 	1,	/* Elements count */
-	&asn_DEF_ExtensibleSet_specs	/* Additional specs */
+	&asn_SPC_ExtensibleSet_1_specs	/* Additional specs */
 };
 
 
@@ -471,7 +471,7 @@ typedef struct ExtensibleSequence {
 
 /*** <<< STAT-DEFS [ExtensibleSequence] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_ExtensibleSequence[] = {
+static asn_TYPE_member_t asn_MBR_ExtensibleSequence_1[] = {
 	{ ATF_POINTER, 2, offsetof(struct ExtensibleSequence, string),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
@@ -487,17 +487,17 @@ static asn_TYPE_member_t asn_MBR_ExtensibleSequence[] = {
 		.name = "integer"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ExtensibleSequence_tags[] = {
+static ber_tlv_tag_t asn_DEF_ExtensibleSequence_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_DEF_ExtensibleSequence_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence_1_tag2el[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string at 49 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* integer at 51 */
 };
-static asn_SEQUENCE_specifics_t asn_DEF_ExtensibleSequence_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_1_specs = {
 	sizeof(struct ExtensibleSequence),
 	offsetof(struct ExtensibleSequence, _asn_ctx),
-	asn_DEF_ExtensibleSequence_tag2el,
+	asn_MAP_ExtensibleSequence_1_tag2el,
 	2,	/* Count of tags in the map */
 	0,	/* Start extensions */
 	3	/* Stop extensions */
@@ -513,15 +513,15 @@ asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ExtensibleSequence_tags,
-	sizeof(asn_DEF_ExtensibleSequence_tags)
-		/sizeof(asn_DEF_ExtensibleSequence_tags[0]), /* 1 */
-	asn_DEF_ExtensibleSequence_tags,	/* Same as above */
-	sizeof(asn_DEF_ExtensibleSequence_tags)
-		/sizeof(asn_DEF_ExtensibleSequence_tags[0]), /* 1 */
-	asn_MBR_ExtensibleSequence,
+	asn_DEF_ExtensibleSequence_1_tags,
+	sizeof(asn_DEF_ExtensibleSequence_1_tags)
+		/sizeof(asn_DEF_ExtensibleSequence_1_tags[0]), /* 1 */
+	asn_DEF_ExtensibleSequence_1_tags,	/* Same as above */
+	sizeof(asn_DEF_ExtensibleSequence_1_tags)
+		/sizeof(asn_DEF_ExtensibleSequence_1_tags[0]), /* 1 */
+	asn_MBR_ExtensibleSequence_1,
 	2,	/* Elements count */
-	&asn_DEF_ExtensibleSequence_specs	/* Additional specs */
+	&asn_SPC_ExtensibleSequence_1_specs	/* Additional specs */
 };
 
 
@@ -547,7 +547,7 @@ typedef struct SetOf {
 
 /*** <<< STAT-DEFS [SetOf] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_SetOf[] = {
+static asn_TYPE_member_t asn_MBR_SetOf_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 		.tag_mode = 0,
@@ -556,10 +556,10 @@ static asn_TYPE_member_t asn_MBR_SetOf[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_SetOf_tags[] = {
+static ber_tlv_tag_t asn_DEF_SetOf_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_SetOf_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SetOf_1_specs = {
 	sizeof(struct SetOf),
 	offsetof(struct SetOf, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -575,15 +575,15 @@ asn_TYPE_descriptor_t asn_DEF_SetOf = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SetOf_tags,
-	sizeof(asn_DEF_SetOf_tags)
-		/sizeof(asn_DEF_SetOf_tags[0]), /* 1 */
-	asn_DEF_SetOf_tags,	/* Same as above */
-	sizeof(asn_DEF_SetOf_tags)
-		/sizeof(asn_DEF_SetOf_tags[0]), /* 1 */
-	asn_MBR_SetOf,
+	asn_DEF_SetOf_1_tags,
+	sizeof(asn_DEF_SetOf_1_tags)
+		/sizeof(asn_DEF_SetOf_1_tags[0]), /* 1 */
+	asn_DEF_SetOf_1_tags,	/* Same as above */
+	sizeof(asn_DEF_SetOf_1_tags)
+		/sizeof(asn_DEF_SetOf_1_tags[0]), /* 1 */
+	asn_MBR_SetOf_1,
 	1,	/* Single element */
-	&asn_DEF_SetOf_specs	/* Additional specs */
+	&asn_SPC_SetOf_1_specs	/* Additional specs */
 };
 
 
@@ -609,7 +609,7 @@ typedef struct SetOfNULL {
 
 /*** <<< STAT-DEFS [SetOfNULL] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_SetOfNULL[] = {
+static asn_TYPE_member_t asn_MBR_SetOfNULL_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
 		.tag_mode = 0,
@@ -618,10 +618,10 @@ static asn_TYPE_member_t asn_MBR_SetOfNULL[] = {
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_SetOfNULL_tags[] = {
+static ber_tlv_tag_t asn_DEF_SetOfNULL_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_SetOfNULL_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SetOfNULL_1_specs = {
 	sizeof(struct SetOfNULL),
 	offsetof(struct SetOfNULL, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -637,15 +637,15 @@ asn_TYPE_descriptor_t asn_DEF_SetOfNULL = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SetOfNULL_tags,
-	sizeof(asn_DEF_SetOfNULL_tags)
-		/sizeof(asn_DEF_SetOfNULL_tags[0]), /* 1 */
-	asn_DEF_SetOfNULL_tags,	/* Same as above */
-	sizeof(asn_DEF_SetOfNULL_tags)
-		/sizeof(asn_DEF_SetOfNULL_tags[0]), /* 1 */
-	asn_MBR_SetOfNULL,
+	asn_DEF_SetOfNULL_1_tags,
+	sizeof(asn_DEF_SetOfNULL_1_tags)
+		/sizeof(asn_DEF_SetOfNULL_1_tags[0]), /* 1 */
+	asn_DEF_SetOfNULL_1_tags,	/* Same as above */
+	sizeof(asn_DEF_SetOfNULL_1_tags)
+		/sizeof(asn_DEF_SetOfNULL_1_tags[0]), /* 1 */
+	asn_MBR_SetOfNULL_1,
 	1,	/* Single element */
-	&asn_DEF_SetOfNULL_specs	/* Additional specs */
+	&asn_SPC_SetOfNULL_1_specs	/* Additional specs */
 };
 
 
@@ -657,10 +657,10 @@ asn_TYPE_descriptor_t asn_DEF_SetOfNULL = {
 
 /*** <<< DEPS [SetOfEnums] >>> ***/
 
-typedef enum SetOfEnums_Member {
-	SetOfEnums_Member_one	= 0,
-	SetOfEnums_Member_oneMore	= 1
-} SetOfEnums_Member_e;
+typedef enum Member {
+	Member_one	= 0,
+	Member_oneMore	= 1
+} Member_e;
 extern asn_TYPE_descriptor_t asn_DEF_SetOfEnums;
 
 /*** <<< TYPE-DECLS [SetOfEnums] >>> ***/
@@ -675,12 +675,12 @@ typedef struct SetOfEnums {
 
 /*** <<< FUNC-DECLS [SetOfEnums] >>> ***/
 
-/* extern asn_TYPE_descriptor_t asn_DEF_SetOfEnums_Member;	// (Use -fall-defs-global to expose) */
+/* extern asn_TYPE_descriptor_t asn_DEF_Member_2;	// (Use -fall-defs-global to expose) */
 
 /*** <<< CODE [SetOfEnums] >>> ***/
 
 static int
-SetOfEnums_Member_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+Member_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	/* Replace with underlying type checker */
 	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
@@ -692,7 +692,7 @@ SetOfEnums_Member_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * so here we adjust the DEF accordingly.
  */
 static void
-SetOfEnums_Member_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+Member_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
 	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
 	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
@@ -705,105 +705,105 @@ SetOfEnums_Member_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 }
 
 static void
-SetOfEnums_Member_free(asn_TYPE_descriptor_t *td,
+Member_2_free(asn_TYPE_descriptor_t *td,
 		void *struct_ptr, int contents_only) {
-	SetOfEnums_Member_inherit_TYPE_descriptor(td);
+	Member_2_inherit_TYPE_descriptor(td);
 	td->free_struct(td, struct_ptr, contents_only);
 }
 
 static int
-SetOfEnums_Member_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+Member_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
 		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	SetOfEnums_Member_inherit_TYPE_descriptor(td);
+	Member_2_inherit_TYPE_descriptor(td);
 	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
 }
 
 static asn_dec_rval_t
-SetOfEnums_Member_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+Member_2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, void *bufptr, size_t size, int tag_mode) {
-	SetOfEnums_Member_inherit_TYPE_descriptor(td);
+	Member_2_inherit_TYPE_descriptor(td);
 	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
 }
 
 static asn_enc_rval_t
-SetOfEnums_Member_encode_der(asn_TYPE_descriptor_t *td,
+Member_2_encode_der(asn_TYPE_descriptor_t *td,
 		void *structure, int tag_mode, ber_tlv_tag_t tag,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	SetOfEnums_Member_inherit_TYPE_descriptor(td);
+	Member_2_inherit_TYPE_descriptor(td);
 	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
 }
 
 static asn_dec_rval_t
-SetOfEnums_Member_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+Member_2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	SetOfEnums_Member_inherit_TYPE_descriptor(td);
+	Member_2_inherit_TYPE_descriptor(td);
 	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
 }
 
 static asn_enc_rval_t
-SetOfEnums_Member_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+Member_2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
 		int ilevel, enum xer_encoder_flags_e flags,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	SetOfEnums_Member_inherit_TYPE_descriptor(td);
+	Member_2_inherit_TYPE_descriptor(td);
 	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
 }
 
 
 /*** <<< STAT-DEFS [SetOfEnums] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_SetOfEnums_Member_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_Member_2_value2enum[] = {
 	{ 0,	3,	"one" },
 	{ 1,	7,	"oneMore" }
 };
-static unsigned int asn_MAP_SetOfEnums_Member_enum2value[] = {
+static unsigned int asn_MAP_Member_2_enum2value[] = {
 	0,	/* one(0) */
 	1	/* oneMore(1) */
 };
-static asn_INTEGER_specifics_t asn_DEF_SetOfEnums_Member_specs = {
-	asn_MAP_SetOfEnums_Member_value2enum,	/* "tag" => N; sorted by tag */
-	asn_MAP_SetOfEnums_Member_enum2value,	/* N => "tag"; sorted by N */
+static asn_INTEGER_specifics_t asn_SPC_Member_2_specs = {
+	asn_MAP_Member_2_value2enum,	/* "tag" => N; sorted by tag */
+	asn_MAP_Member_2_enum2value,	/* N => "tag"; sorted by N */
 	2,	/* Number of elements in the maps */
 	0,	/* Enumeration is not extensible */
 	1	/* Strict enumeration */
 };
-static ber_tlv_tag_t asn_DEF_SetOfEnums_Member_tags[] = {
+static ber_tlv_tag_t asn_DEF_Member_2_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
 static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_SetOfEnums_Member = {
+asn_TYPE_descriptor_t asn_DEF_Member_2 = {
 	"",
 	"",
-	SetOfEnums_Member_free,
-	SetOfEnums_Member_print,
-	SetOfEnums_Member_constraint,
-	SetOfEnums_Member_decode_ber,
-	SetOfEnums_Member_encode_der,
-	SetOfEnums_Member_decode_xer,
-	SetOfEnums_Member_encode_xer,
+	Member_2_free,
+	Member_2_print,
+	Member_2_constraint,
+	Member_2_decode_ber,
+	Member_2_encode_der,
+	Member_2_decode_xer,
+	Member_2_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SetOfEnums_Member_tags,
-	sizeof(asn_DEF_SetOfEnums_Member_tags)
-		/sizeof(asn_DEF_SetOfEnums_Member_tags[0]), /* 1 */
-	asn_DEF_SetOfEnums_Member_tags,	/* Same as above */
-	sizeof(asn_DEF_SetOfEnums_Member_tags)
-		/sizeof(asn_DEF_SetOfEnums_Member_tags[0]), /* 1 */
+	asn_DEF_Member_2_tags,
+	sizeof(asn_DEF_Member_2_tags)
+		/sizeof(asn_DEF_Member_2_tags[0]), /* 1 */
+	asn_DEF_Member_2_tags,	/* Same as above */
+	sizeof(asn_DEF_Member_2_tags)
+		/sizeof(asn_DEF_Member_2_tags[0]), /* 1 */
 	0, 0,	/* Defined elsewhere */
-	&asn_DEF_SetOfEnums_Member_specs	/* Additional specs */
+	&asn_SPC_Member_2_specs	/* Additional specs */
 };
 
-static asn_TYPE_member_t asn_MBR_SetOfEnums[] = {
+static asn_TYPE_member_t asn_MBR_SetOfEnums_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_SetOfEnums_Member,
+		.type = (void *)&asn_DEF_Member_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_SetOfEnums_tags[] = {
+static ber_tlv_tag_t asn_DEF_SetOfEnums_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_SetOfEnums_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SetOfEnums_1_specs = {
 	sizeof(struct SetOfEnums),
 	offsetof(struct SetOfEnums, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -819,15 +819,15 @@ asn_TYPE_descriptor_t asn_DEF_SetOfEnums = {
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SetOfEnums_tags,
-	sizeof(asn_DEF_SetOfEnums_tags)
-		/sizeof(asn_DEF_SetOfEnums_tags[0]), /* 1 */
-	asn_DEF_SetOfEnums_tags,	/* Same as above */
-	sizeof(asn_DEF_SetOfEnums_tags)
-		/sizeof(asn_DEF_SetOfEnums_tags[0]), /* 1 */
-	asn_MBR_SetOfEnums,
+	asn_DEF_SetOfEnums_1_tags,
+	sizeof(asn_DEF_SetOfEnums_1_tags)
+		/sizeof(asn_DEF_SetOfEnums_1_tags[0]), /* 1 */
+	asn_DEF_SetOfEnums_1_tags,	/* Same as above */
+	sizeof(asn_DEF_SetOfEnums_1_tags)
+		/sizeof(asn_DEF_SetOfEnums_1_tags[0]), /* 1 */
+	asn_MBR_SetOfEnums_1,
 	1,	/* Single element */
-	&asn_DEF_SetOfEnums_specs	/* Additional specs */
+	&asn_SPC_SetOfEnums_1_specs	/* Additional specs */
 };
 
 
@@ -839,10 +839,6 @@ asn_TYPE_descriptor_t asn_DEF_SetOfEnums = {
 
 /*** <<< DEPS [SequenceOf] >>> ***/
 
-typedef enum id {
-	id_one	= 1,
-	id_two	= 2
-} id_e;
 extern asn_TYPE_descriptor_t asn_DEF_SequenceOf;
 
 /*** <<< TYPE-DECLS [SequenceOf] >>> ***/
@@ -855,139 +851,21 @@ typedef struct SequenceOf {
 	asn_struct_ctx_t _asn_ctx;
 } SequenceOf_t;
 
-/*** <<< FUNC-DECLS [SequenceOf] >>> ***/
-
-/* extern asn_TYPE_descriptor_t asn_DEF_id;	// (Use -fall-defs-global to expose) */
-
-/*** <<< CODE [SequenceOf] >>> ***/
-
-static int
-id_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-			asn_app_consume_bytes_f *app_errlog, void *app_key) {
-	/* Replace with underlying type checker */
-	td->check_constraints = asn_DEF_INTEGER.check_constraints;
-	return td->check_constraints(td, sptr, app_errlog, app_key);
-}
-
-/*
- * This type is implemented using INTEGER,
- * so here we adjust the DEF accordingly.
- */
-static void
-id_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-	td->free_struct    = asn_DEF_INTEGER.free_struct;
-	td->print_struct   = asn_DEF_INTEGER.print_struct;
-	td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
-	td->der_encoder    = asn_DEF_INTEGER.der_encoder;
-	td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
-	td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
-	td->elements       = asn_DEF_INTEGER.elements;
-	td->elements_count = asn_DEF_INTEGER.elements_count;
-    /* td->specifics      = asn_DEF_INTEGER.specifics;	// Defined explicitly */
-}
-
-static void
-id_free(asn_TYPE_descriptor_t *td,
-		void *struct_ptr, int contents_only) {
-	id_inherit_TYPE_descriptor(td);
-	td->free_struct(td, struct_ptr, contents_only);
-}
-
-static int
-id_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-	id_inherit_TYPE_descriptor(td);
-	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-static asn_dec_rval_t
-id_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-		void **structure, void *bufptr, size_t size, int tag_mode) {
-	id_inherit_TYPE_descriptor(td);
-	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-static asn_enc_rval_t
-id_encode_der(asn_TYPE_descriptor_t *td,
-		void *structure, int tag_mode, ber_tlv_tag_t tag,
-		asn_app_consume_bytes_f *cb, void *app_key) {
-	id_inherit_TYPE_descriptor(td);
-	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-static asn_dec_rval_t
-id_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-		void **structure, const char *opt_mname, void *bufptr, size_t size) {
-	id_inherit_TYPE_descriptor(td);
-	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-static asn_enc_rval_t
-id_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
-		int ilevel, enum xer_encoder_flags_e flags,
-		asn_app_consume_bytes_f *cb, void *app_key) {
-	id_inherit_TYPE_descriptor(td);
-	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
-
 /*** <<< STAT-DEFS [SequenceOf] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_id_value2enum[] = {
-	{ 1,	3,	"one" },
-	{ 2,	3,	"two" }
-	/* This list is extensible */
-};
-static unsigned int asn_MAP_id_enum2value[] = {
-	0,	/* one(1) */
-	1	/* two(2) */
-	/* This list is extensible */
-};
-static asn_INTEGER_specifics_t asn_DEF_id_specs = {
-	asn_MAP_id_value2enum,	/* "tag" => N; sorted by tag */
-	asn_MAP_id_enum2value,	/* N => "tag"; sorted by N */
-	2,	/* Number of elements in the maps */
-	1,	/* Enumeration is extensible */
-	0
-};
-static ber_tlv_tag_t asn_DEF_id_tags[] = {
-	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
-};
-static /* Use -fall-defs-global to expose */
-asn_TYPE_descriptor_t asn_DEF_id = {
-	"",
-	"",
-	id_free,
-	id_print,
-	id_constraint,
-	id_decode_ber,
-	id_encode_der,
-	id_decode_xer,
-	id_encode_xer,
-	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_id_tags,
-	sizeof(asn_DEF_id_tags)
-		/sizeof(asn_DEF_id_tags[0]), /* 1 */
-	asn_DEF_id_tags,	/* Same as above */
-	sizeof(asn_DEF_id_tags)
-		/sizeof(asn_DEF_id_tags[0]), /* 1 */
-	0, 0,	/* Defined elsewhere */
-	&asn_DEF_id_specs	/* Additional specs */
-};
-
-static asn_TYPE_member_t asn_MBR_SequenceOf[] = {
+static asn_TYPE_member_t asn_MBR_SequenceOf_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
-		.type = (void *)&asn_DEF_id,
+		.type = (void *)&asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.name = "id"
 		},
 };
-static ber_tlv_tag_t asn_DEF_SequenceOf_tags[] = {
+static ber_tlv_tag_t asn_DEF_SequenceOf_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_SequenceOf_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SequenceOf_1_specs = {
 	sizeof(struct SequenceOf),
 	offsetof(struct SequenceOf, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -1003,15 +881,15 @@ asn_TYPE_descriptor_t asn_DEF_SequenceOf = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SequenceOf_tags,
-	sizeof(asn_DEF_SequenceOf_tags)
-		/sizeof(asn_DEF_SequenceOf_tags[0]), /* 1 */
-	asn_DEF_SequenceOf_tags,	/* Same as above */
-	sizeof(asn_DEF_SequenceOf_tags)
-		/sizeof(asn_DEF_SequenceOf_tags[0]), /* 1 */
-	asn_MBR_SequenceOf,
+	asn_DEF_SequenceOf_1_tags,
+	sizeof(asn_DEF_SequenceOf_1_tags)
+		/sizeof(asn_DEF_SequenceOf_1_tags[0]), /* 1 */
+	asn_DEF_SequenceOf_1_tags,	/* Same as above */
+	sizeof(asn_DEF_SequenceOf_1_tags)
+		/sizeof(asn_DEF_SequenceOf_1_tags[0]), /* 1 */
+	asn_MBR_SequenceOf_1,
 	1,	/* Single element */
-	&asn_DEF_SequenceOf_specs	/* Additional specs */
+	&asn_SPC_SequenceOf_1_specs	/* Additional specs */
 };
 
 
@@ -1037,7 +915,7 @@ typedef struct SeqOfZuka {
 
 /*** <<< STAT-DEFS [SeqOfZuka] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_SeqOfZuka[] = {
+static asn_TYPE_member_t asn_MBR_SeqOfZuka_1[] = {
 	{ ATF_NOFLAGS, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
 		.tag_mode = 0,
@@ -1046,10 +924,10 @@ static asn_TYPE_member_t asn_MBR_SeqOfZuka[] = {
 		.name = "zuka"
 		},
 };
-static ber_tlv_tag_t asn_DEF_SeqOfZuka_tags[] = {
+static ber_tlv_tag_t asn_DEF_SeqOfZuka_1_tags[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_DEF_SeqOfZuka_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SeqOfZuka_1_specs = {
 	sizeof(struct SeqOfZuka),
 	offsetof(struct SeqOfZuka, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -1065,14 +943,14 @@ asn_TYPE_descriptor_t asn_DEF_SeqOfZuka = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SeqOfZuka_tags,
-	sizeof(asn_DEF_SeqOfZuka_tags)
-		/sizeof(asn_DEF_SeqOfZuka_tags[0]), /* 1 */
-	asn_DEF_SeqOfZuka_tags,	/* Same as above */
-	sizeof(asn_DEF_SeqOfZuka_tags)
-		/sizeof(asn_DEF_SeqOfZuka_tags[0]), /* 1 */
-	asn_MBR_SeqOfZuka,
+	asn_DEF_SeqOfZuka_1_tags,
+	sizeof(asn_DEF_SeqOfZuka_1_tags)
+		/sizeof(asn_DEF_SeqOfZuka_1_tags[0]), /* 1 */
+	asn_DEF_SeqOfZuka_1_tags,	/* Same as above */
+	sizeof(asn_DEF_SeqOfZuka_1_tags)
+		/sizeof(asn_DEF_SeqOfZuka_1_tags[0]), /* 1 */
+	asn_MBR_SeqOfZuka_1,
 	1,	/* Single element */
-	&asn_DEF_SeqOfZuka_specs	/* Additional specs */
+	&asn_SPC_SeqOfZuka_1_specs	/* Additional specs */
 };