diff --git a/tests/19-param-OK.asn1.-P b/tests/19-param-OK.asn1.-P
index 8ffd617..321e71a 100644
--- a/tests/19-param-OK.asn1.-P
+++ b/tests/19-param-OK.asn1.-P
@@ -32,7 +32,7 @@
 /*** <<< CODE [Certificate] >>> ***/
 
 static int
-memb_signature_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_signature_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 	size_t size;
@@ -71,6 +71,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "version"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct toBeSigned, signature),
@@ -78,6 +80,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_OBJECT_IDENTIFIER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "signature"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct toBeSigned, issuer),
@@ -85,22 +89,25 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Name,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "issuer"
 		},
 };
-static ber_tlv_tag_t asn_DEF_toBeSigned_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_toBeSigned_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_toBeSigned_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_toBeSigned_tag2el_2[] = {
     { (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_SPC_toBeSigned_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_toBeSigned_specs_2 = {
 	sizeof(struct toBeSigned),
 	offsetof(struct toBeSigned, _asn_ctx),
-	asn_MAP_toBeSigned_2_tag2el,
+	asn_MAP_toBeSigned_tag2el_2,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -115,16 +122,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_toBeSigned_tags_2,
+	sizeof(asn_DEF_toBeSigned_tags_2)
+		/sizeof(asn_DEF_toBeSigned_tags_2[0]), /* 1 */
+	asn_DEF_toBeSigned_tags_2,	/* Same as above */
+	sizeof(asn_DEF_toBeSigned_tags_2)
+		/sizeof(asn_DEF_toBeSigned_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_toBeSigned_2,
 	3,	/* Elements count */
-	&asn_SPC_toBeSigned_2_specs	/* Additional specs */
+	&asn_SPC_toBeSigned_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Certificate_1[] = {
@@ -133,6 +142,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_toBeSigned_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "toBeSigned"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Certificate, algorithm),
@@ -140,29 +151,34 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_OBJECT_IDENTIFIER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "algorithm"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Certificate, signature),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_BIT_STRING,
-		.memb_constraints = memb_signature_1_constraint,
+		.memb_constraints = memb_signature_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "signature"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Certificate_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Certificate_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Certificate_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Certificate_tag2el_1[] = {
     { (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_SPC_Certificate_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Certificate_specs_1 = {
 	sizeof(struct Certificate),
 	offsetof(struct Certificate, _asn_ctx),
-	asn_MAP_Certificate_1_tag2el,
+	asn_MAP_Certificate_tag2el_1,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -176,16 +192,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Certificate_tags_1,
+	sizeof(asn_DEF_Certificate_tags_1)
+		/sizeof(asn_DEF_Certificate_tags_1[0]), /* 1 */
+	asn_DEF_Certificate_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Certificate_tags_1)
+		/sizeof(asn_DEF_Certificate_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Certificate_1,
 	3,	/* Elements count */
-	&asn_SPC_Certificate_1_specs	/* Additional specs */
+	&asn_SPC_Certificate_specs_1	/* Additional specs */
 };
 
 
@@ -223,13 +241,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_RelativeDistinguishedName,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Name_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Name_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_Name_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Name_specs_1 = {
 	sizeof(struct Name),
 	offsetof(struct Name, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -244,16 +264,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Name_tags_1,
+	sizeof(asn_DEF_Name_tags_1)
+		/sizeof(asn_DEF_Name_tags_1[0]), /* 1 */
+	asn_DEF_Name_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Name_tags_1)
+		/sizeof(asn_DEF_Name_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Name_1,
 	1,	/* Single element */
-	&asn_SPC_Name_1_specs	/* Additional specs */
+	&asn_SPC_Name_specs_1	/* Additional specs */
 };
 
 
@@ -307,7 +329,7 @@
 /*** <<< CODE [RelativeDistinguishedName] >>> ***/
 
 static int
-memb_IA5String_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_IA5String_constraint_1(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;
 	
@@ -338,14 +360,16 @@
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_IA5String,
-		.memb_constraints = memb_IA5String_1_constraint,
+		.memb_constraints = memb_IA5String_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_RelativeDistinguishedName_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_RelativeDistinguishedName_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_RelativeDistinguishedName_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_RelativeDistinguishedName_specs_1 = {
 	sizeof(struct RelativeDistinguishedName),
 	offsetof(struct RelativeDistinguishedName, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -360,15 +384,17 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_RelativeDistinguishedName_tags_1,
+	sizeof(asn_DEF_RelativeDistinguishedName_tags_1)
+		/sizeof(asn_DEF_RelativeDistinguishedName_tags_1[0]), /* 1 */
+	asn_DEF_RelativeDistinguishedName_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RelativeDistinguishedName_tags_1)
+		/sizeof(asn_DEF_RelativeDistinguishedName_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_RelativeDistinguishedName_1,
 	1,	/* Single element */
-	&asn_SPC_RelativeDistinguishedName_1_specs	/* Additional specs */
+	&asn_SPC_RelativeDistinguishedName_specs_1	/* Additional specs */
 };
 
diff --git a/tests/30-set-OK.asn1.-P b/tests/30-set-OK.asn1.-P
index 439f0de..6525088 100644
--- a/tests/30-set-OK.asn1.-P
+++ b/tests/30-set-OK.asn1.-P
@@ -49,6 +49,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "i"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct T, s),
@@ -56,6 +58,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_IA5String,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "s"
 		},
 	{ ATF_POINTER, 1, offsetof(struct T, b),
@@ -63,30 +67,32 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_BOOLEAN,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_tag2el_1[] = {
     { (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_MAP_T_1_mmap[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_T_mmap_1[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (1 << 6) | (0 << 5)
 };
-static asn_SET_specifics_t asn_SPC_T_1_specs = {
+static asn_SET_specifics_t asn_SPC_T_specs_1 = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
 	offsetof(struct T, _presence_map),
-	asn_MAP_T_1_tag2el,
+	asn_MAP_T_tag2el_1,
 	3,	/* Count of tags in the map */
-	asn_MAP_T_1_tag2el,	/* Same as above */
+	asn_MAP_T_tag2el_1,	/* Same as above */
 	3,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_MAP_T_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_T_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_T = {
 	"T",
@@ -98,15 +104,17 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T_1,
 	3,	/* Elements count */
-	&asn_SPC_T_1_specs	/* Additional specs */
+	&asn_SPC_T_specs_1	/* Additional specs */
 };
 
diff --git a/tests/31-set-of-OK.asn1 b/tests/31-set-of-OK.asn1
index c8fa51e..ddfe51c 100644
--- a/tests/31-set-of-OK.asn1
+++ b/tests/31-set-of-OK.asn1
@@ -37,4 +37,6 @@
 			-- not to the SET OF's embedded SEQUENCE!
 		}
 
+	SSS ::= SEQUENCE OF SET OF SEQUENCE OF BIT STRING
+
 END
diff --git a/tests/31-set-of-OK.asn1.-EF b/tests/31-set-of-OK.asn1.-EF
index f97ce2a..bf6f99d 100644
--- a/tests/31-set-of-OK.asn1.-EF
+++ b/tests/31-set-of-OK.asn1.-EF
@@ -23,4 +23,6 @@
     }
 }
 
+SSS ::= SEQUENCE OF SET OF SEQUENCE OF BIT STRING
+
 END
diff --git a/tests/31-set-of-OK.asn1.-P b/tests/31-set-of-OK.asn1.-P
index d1e5c82..23cf7f0 100644
--- a/tests/31-set-of-OK.asn1.-P
+++ b/tests/31-set-of-OK.asn1.-P
@@ -33,13 +33,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Tree,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Forest_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Forest_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_Forest_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Forest_specs_1 = {
 	sizeof(struct Forest),
 	offsetof(struct Forest, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -54,16 +56,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Forest_tags_1,
+	sizeof(asn_DEF_Forest_tags_1)
+		/sizeof(asn_DEF_Forest_tags_1[0]), /* 1 */
+	asn_DEF_Forest_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Forest_tags_1)
+		/sizeof(asn_DEF_Forest_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Forest_1,
 	1,	/* Single element */
-	&asn_SPC_Forest_1_specs	/* Additional specs */
+	&asn_SPC_Forest_specs_1	/* Additional specs */
 };
 
 
@@ -94,6 +98,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "height"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Tree, width),
@@ -101,21 +107,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "width"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Tree_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Tree_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Tree_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Tree_tag2el_1[] = {
     { (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_SPC_Tree_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Tree_specs_1 = {
 	sizeof(struct Tree),
 	offsetof(struct Tree, _asn_ctx),
-	asn_MAP_Tree_1_tag2el,
+	asn_MAP_Tree_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -129,16 +138,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Tree_tags_1,
+	sizeof(asn_DEF_Tree_tags_1)
+		/sizeof(asn_DEF_Tree_tags_1[0]), /* 1 */
+	asn_DEF_Tree_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Tree_tags_1)
+		/sizeof(asn_DEF_Tree_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Tree_1,
 	2,	/* Elements count */
-	&asn_SPC_Tree_1_specs	/* Additional specs */
+	&asn_SPC_Tree_specs_1	/* Additional specs */
 };
 
 
@@ -236,14 +247,16 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Forest,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_trees_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_trees_tags_2[] = {
 	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_trees_2_specs = {
+static asn_SET_OF_specifics_t asn_SPC_trees_specs_2 = {
 	sizeof(struct trees),
 	offsetof(struct trees, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -259,16 +272,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_trees_tags_2,
+	sizeof(asn_DEF_trees_tags_2)
+		/sizeof(asn_DEF_trees_tags_2[0]) - 1, /* 1 */
+	asn_DEF_trees_tags_2,	/* Same as above */
+	sizeof(asn_DEF_trees_tags_2)
+		/sizeof(asn_DEF_trees_tags_2[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_trees_2,
 	1,	/* Single element */
-	&asn_SPC_trees_2_specs	/* Additional specs */
+	&asn_SPC_trees_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Member_5[] = {
@@ -277,27 +292,30 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_BIT_STRING,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "cup-of-coffee"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Member_5_tags[] = {
+static ber_tlv_tag_t asn_DEF_Member_tags_5[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Member_5_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Member_tag2el_5[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 0, 0, 0 } /* cup-of-coffee at 32 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Member_5_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Member_specs_5 = {
 	sizeof(struct Member),
 	offsetof(struct Member, _asn_ctx),
-	asn_MAP_Member_5_tag2el,
+	asn_MAP_Member_tag2el_5,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	0,	/* Start extensions */
 	2	/* Stop extensions */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_Member_5 = {
-	"",
-	"",
+	"SEQUENCE",
+	"SEQUENCE",
 	SEQUENCE_free,
 	SEQUENCE_print,
 	SEQUENCE_constraint,
@@ -305,16 +323,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Member_5_tags,
-	sizeof(asn_DEF_Member_5_tags)
-		/sizeof(asn_DEF_Member_5_tags[0]), /* 1 */
-	asn_DEF_Member_5_tags,	/* Same as above */
-	sizeof(asn_DEF_Member_5_tags)
-		/sizeof(asn_DEF_Member_5_tags[0]), /* 1 */
+	asn_DEF_Member_tags_5,
+	sizeof(asn_DEF_Member_tags_5)
+		/sizeof(asn_DEF_Member_tags_5[0]), /* 1 */
+	asn_DEF_Member_tags_5,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_5)
+		/sizeof(asn_DEF_Member_tags_5[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Member_5,
 	1,	/* Elements count */
-	&asn_SPC_Member_5_specs	/* Additional specs */
+	&asn_SPC_Member_specs_5	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_anything_4[] = {
@@ -323,14 +343,16 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Member_5,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_anything_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_anything_tags_4[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_anything_4_specs = {
+static asn_SET_OF_specifics_t asn_SPC_anything_specs_4 = {
 	sizeof(struct anything),
 	offsetof(struct anything, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -346,16 +368,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_anything_4_tags,
-	sizeof(asn_DEF_anything_4_tags)
-		/sizeof(asn_DEF_anything_4_tags[0]) - 1, /* 1 */
-	asn_DEF_anything_4_tags,	/* Same as above */
-	sizeof(asn_DEF_anything_4_tags)
-		/sizeof(asn_DEF_anything_4_tags[0]), /* 2 */
+	asn_DEF_anything_tags_4,
+	sizeof(asn_DEF_anything_tags_4)
+		/sizeof(asn_DEF_anything_tags_4[0]) - 1, /* 1 */
+	asn_DEF_anything_tags_4,	/* Same as above */
+	sizeof(asn_DEF_anything_tags_4)
+		/sizeof(asn_DEF_anything_tags_4[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_anything_4,
 	1,	/* Single element */
-	&asn_SPC_anything_4_specs	/* Additional specs */
+	&asn_SPC_anything_specs_4	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_other_9[] = {
@@ -364,6 +388,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct other, choice.b),
@@ -371,21 +397,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_other_9_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_other_tag2el_9[] = {
     { (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_SPC_other_9_specs = {
+static asn_CHOICE_specifics_t asn_SPC_other_specs_9 = {
 	sizeof(struct other),
 	offsetof(struct other, _asn_ctx),
 	offsetof(struct other, present),
 	sizeof(((struct other *)0)->present),
-	asn_MAP_other_9_tag2el,
+	asn_MAP_other_tag2el_9,
 	2,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_other_9 = {
@@ -398,14 +427,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_other_9,
 	2,	/* Elements count */
-	&asn_SPC_other_9_specs	/* Additional specs */
+	&asn_SPC_other_specs_9	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Stuff_1[] = {
@@ -414,6 +445,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_trees_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "trees"
 		},
 	{ ATF_POINTER, 2, offsetof(struct Stuff, anything),
@@ -421,6 +454,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_anything_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "anything"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Stuff, other),
@@ -428,36 +463,38 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_other_9,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "other"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Stuff_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Stuff_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Stuff_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Stuff_tag2el_1[] = {
     { (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_MAP_Stuff_1_tag2el_cxer[] = {
+static asn_TYPE_tag2member_t asn_MAP_Stuff_tag2el_cxer_1[] = {
     { (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_MAP_Stuff_1_mmap[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Stuff_mmap_1[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(0 << 7) | (0 << 6) | (0 << 5)
 };
-static asn_SET_specifics_t asn_SPC_Stuff_1_specs = {
+static asn_SET_specifics_t asn_SPC_Stuff_specs_1 = {
 	sizeof(struct Stuff),
 	offsetof(struct Stuff, _asn_ctx),
 	offsetof(struct Stuff, _presence_map),
-	asn_MAP_Stuff_1_tag2el,
+	asn_MAP_Stuff_tag2el_1,
 	4,	/* Count of tags in the map */
-	asn_MAP_Stuff_1_tag2el_cxer,
+	asn_MAP_Stuff_tag2el_cxer_1,
 	3,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_MAP_Stuff_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Stuff_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Stuff = {
 	"Stuff",
@@ -469,15 +506,182 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Stuff_tags_1,
+	sizeof(asn_DEF_Stuff_tags_1)
+		/sizeof(asn_DEF_Stuff_tags_1[0]), /* 1 */
+	asn_DEF_Stuff_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Stuff_tags_1)
+		/sizeof(asn_DEF_Stuff_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Stuff_1,
 	3,	/* Elements count */
-	&asn_SPC_Stuff_1_specs	/* Additional specs */
+	&asn_SPC_Stuff_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [SSS] >>> ***/
+
+#include <asn_SEQUENCE_OF.h>
+#include <asn_SET_OF.h>
+#include <BIT_STRING.h>
+#include <constr_SEQUENCE_OF.h>
+#include <constr_SET_OF.h>
+
+/*** <<< TYPE-DECLS [SSS] >>> ***/
+
+typedef struct SSS {
+	A_SEQUENCE_OF(struct Member {
+		A_SET_OF(struct Member {
+			A_SEQUENCE_OF(BIT_STRING_t) list;
+			
+			/* Context for parsing across buffer boundaries */
+			asn_struct_ctx_t _asn_ctx;
+		} ) list;
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} ) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} SSS_t;
+
+/*** <<< FUNC-DECLS [SSS] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_SSS;
+
+/*** <<< STAT-DEFS [SSS] >>> ***/
+
+static asn_TYPE_member_t asn_MBR_Member_3[] = {
+	{ ATF_POINTER, 0, 0,
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_BIT_STRING,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = ""
+		},
+};
+static ber_tlv_tag_t asn_DEF_Member_tags_3[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_Member_specs_3 = {
+	sizeof(struct Member),
+	offsetof(struct Member, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_Member_3 = {
+	"SEQUENCE OF",
+	"SEQUENCE_OF",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Member_tags_3,
+	sizeof(asn_DEF_Member_tags_3)
+		/sizeof(asn_DEF_Member_tags_3[0]), /* 1 */
+	asn_DEF_Member_tags_3,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_3)
+		/sizeof(asn_DEF_Member_tags_3[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Member_3,
+	1,	/* Single element */
+	&asn_SPC_Member_specs_3	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_Member_2[] = {
+	{ ATF_POINTER, 0, 0,
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Member_3,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = ""
+		},
+};
+static ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_Member_specs_2 = {
+	sizeof(struct Member),
+	offsetof(struct Member, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_Member_2 = {
+	"SET OF",
+	"SET_OF",
+	SET_OF_free,
+	SET_OF_print,
+	SET_OF_constraint,
+	SET_OF_decode_ber,
+	SET_OF_encode_der,
+	SET_OF_decode_xer,
+	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Member_tags_2,
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	asn_DEF_Member_tags_2,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Member_2,
+	1,	/* Single element */
+	&asn_SPC_Member_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SSS_1[] = {
+	{ ATF_POINTER, 0, 0,
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Member_2,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = ""
+		},
+};
+static ber_tlv_tag_t asn_DEF_SSS_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SSS_specs_1 = {
+	sizeof(struct SSS),
+	offsetof(struct SSS, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SSS = {
+	"SSS",
+	"SSS",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SSS_tags_1,
+	sizeof(asn_DEF_SSS_tags_1)
+		/sizeof(asn_DEF_SSS_tags_1[0]), /* 1 */
+	asn_DEF_SSS_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SSS_tags_1)
+		/sizeof(asn_DEF_SSS_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SSS_1,
+	1,	/* Single element */
+	&asn_SPC_SSS_specs_1	/* Additional specs */
 };
 
diff --git a/tests/32-sequence-of-OK.asn1.-P b/tests/32-sequence-of-OK.asn1.-P
index 3e2354b..fd34d5f 100644
--- a/tests/32-sequence-of-OK.asn1.-P
+++ b/tests/32-sequence-of-OK.asn1.-P
@@ -33,13 +33,15 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Fault,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Programming_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Programming_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_Programming_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Programming_specs_1 = {
 	sizeof(struct Programming),
 	offsetof(struct Programming, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -54,16 +56,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Programming_tags_1,
+	sizeof(asn_DEF_Programming_tags_1)
+		/sizeof(asn_DEF_Programming_tags_1[0]), /* 1 */
+	asn_DEF_Programming_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Programming_tags_1)
+		/sizeof(asn_DEF_Programming_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Programming_1,
 	1,	/* Single element */
-	&asn_SPC_Programming_1_specs	/* Additional specs */
+	&asn_SPC_Programming_specs_1	/* Additional specs */
 };
 
 
@@ -101,13 +105,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Error,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Fault_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Fault_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_Fault_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Fault_specs_1 = {
 	sizeof(struct Fault),
 	offsetof(struct Fault, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -122,16 +128,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Fault_tags_1,
+	sizeof(asn_DEF_Fault_tags_1)
+		/sizeof(asn_DEF_Fault_tags_1[0]), /* 1 */
+	asn_DEF_Fault_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Fault_tags_1)
+		/sizeof(asn_DEF_Fault_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Fault_1,
 	1,	/* Single element */
-	&asn_SPC_Fault_1_specs	/* Additional specs */
+	&asn_SPC_Fault_specs_1	/* Additional specs */
 };
 
 
@@ -157,14 +165,15 @@
 
 /*** <<< STAT-DEFS [Error] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Error_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Error_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Error_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Error_specs_1 = {
 	sizeof(struct Error),
 	offsetof(struct Error, _asn_ctx),
 	0,	/* No top level tags */
 	0,	/* No tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -178,14 +187,16 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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 */
+	asn_DEF_Error_tags_1,
+	sizeof(asn_DEF_Error_tags_1)
+		/sizeof(asn_DEF_Error_tags_1[0]), /* 1 */
+	asn_DEF_Error_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Error_tags_1)
+		/sizeof(asn_DEF_Error_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
-	&asn_SPC_Error_1_specs	/* Additional specs */
+	&asn_SPC_Error_specs_1	/* Additional specs */
 };
 
diff --git a/tests/39-sequence-of-OK.asn1.-P b/tests/39-sequence-of-OK.asn1.-P
index 6339c4b..0e4691c 100644
--- a/tests/39-sequence-of-OK.asn1.-P
+++ b/tests/39-sequence-of-OK.asn1.-P
@@ -41,13 +41,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_T2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_collection_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_collection_tags_3[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_collection_3_specs = {
+static asn_SET_OF_specifics_t asn_SPC_collection_specs_3 = {
 	sizeof(struct collection),
 	offsetof(struct collection, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -63,16 +65,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_collection_3_tags,
-	sizeof(asn_DEF_collection_3_tags)
-		/sizeof(asn_DEF_collection_3_tags[0]), /* 1 */
-	asn_DEF_collection_3_tags,	/* Same as above */
-	sizeof(asn_DEF_collection_3_tags)
-		/sizeof(asn_DEF_collection_3_tags[0]), /* 1 */
+	asn_DEF_collection_tags_3,
+	sizeof(asn_DEF_collection_tags_3)
+		/sizeof(asn_DEF_collection_tags_3[0]), /* 1 */
+	asn_DEF_collection_tags_3,	/* Same as above */
+	sizeof(asn_DEF_collection_tags_3)
+		/sizeof(asn_DEF_collection_tags_3[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_collection_3,
 	1,	/* Single element */
-	&asn_SPC_collection_3_specs	/* Additional specs */
+	&asn_SPC_collection_specs_3	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_T_1[] = {
@@ -81,6 +85,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "int"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct T, collection),
@@ -88,21 +94,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_collection_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "collection"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_tag2el_1[] = {
     { (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_SPC_T_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T_specs_1 = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
-	asn_MAP_T_1_tag2el,
+	asn_MAP_T_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -116,16 +125,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T_1,
 	2,	/* Elements count */
-	&asn_SPC_T_1_specs	/* Additional specs */
+	&asn_SPC_T_specs_1	/* Additional specs */
 };
 
 
@@ -157,6 +168,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_BOOLEAN,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "flag"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct T2, str),
@@ -164,21 +177,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_UTF8String,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "str"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T2_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T2_tag2el_1[] = {
     { (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_SPC_T2_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T2_specs_1 = {
 	sizeof(struct T2),
 	offsetof(struct T2, _asn_ctx),
-	asn_MAP_T2_1_tag2el,
+	asn_MAP_T2_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -192,15 +208,17 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T2_tags_1,
+	sizeof(asn_DEF_T2_tags_1)
+		/sizeof(asn_DEF_T2_tags_1[0]), /* 1 */
+	asn_DEF_T2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T2_tags_1)
+		/sizeof(asn_DEF_T2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T2_1,
 	2,	/* Elements count */
-	&asn_SPC_T2_1_specs	/* Additional specs */
+	&asn_SPC_T2_specs_1	/* Additional specs */
 };
 
diff --git a/tests/42-real-life-OK.asn1.-PR b/tests/42-real-life-OK.asn1.-PR
index cd46263..4c41f53 100644
--- a/tests/42-real-life-OK.asn1.-PR
+++ b/tests/42-real-life-OK.asn1.-PR
@@ -40,7 +40,7 @@
 /*** <<< CODE [LogLine] >>> ***/
 
 static int
-memb_varsets_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_varsets_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	size_t size;
 	
@@ -74,13 +74,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_VariablePartSet,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_varsets_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_varsets_tags_3[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_varsets_3_specs = {
+static asn_SET_OF_specifics_t asn_SPC_varsets_specs_3 = {
 	sizeof(struct varsets),
 	offsetof(struct varsets, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -96,16 +98,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_varsets_3_tags,
-	sizeof(asn_DEF_varsets_3_tags)
-		/sizeof(asn_DEF_varsets_3_tags[0]), /* 1 */
-	asn_DEF_varsets_3_tags,	/* Same as above */
-	sizeof(asn_DEF_varsets_3_tags)
-		/sizeof(asn_DEF_varsets_3_tags[0]), /* 1 */
+	asn_DEF_varsets_tags_3,
+	sizeof(asn_DEF_varsets_tags_3)
+		/sizeof(asn_DEF_varsets_tags_3[0]), /* 1 */
+	asn_DEF_varsets_tags_3,	/* Same as above */
+	sizeof(asn_DEF_varsets_tags_3)
+		/sizeof(asn_DEF_varsets_tags_3[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_varsets_3,
 	1,	/* Single element */
-	&asn_SPC_varsets_3_specs	/* Additional specs */
+	&asn_SPC_varsets_specs_3	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_LogLine_1[] = {
@@ -114,28 +118,33 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_IA5String,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "line-digest"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct LogLine, varsets),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_varsets_3,
-		.memb_constraints = memb_varsets_1_constraint,
+		.memb_constraints = memb_varsets_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "varsets"
 		},
 };
-static ber_tlv_tag_t asn_DEF_LogLine_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_LogLine_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_LogLine_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_LogLine_tag2el_1[] = {
     { (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_SPC_LogLine_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_LogLine_specs_1 = {
 	sizeof(struct LogLine),
 	offsetof(struct LogLine, _asn_ctx),
-	asn_MAP_LogLine_1_tag2el,
+	asn_MAP_LogLine_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
 };
@@ -149,16 +158,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_LogLine_tags_1,
+	sizeof(asn_DEF_LogLine_tags_1)
+		/sizeof(asn_DEF_LogLine_tags_1[0]), /* 1 */
+	asn_DEF_LogLine_tags_1,	/* Same as above */
+	sizeof(asn_DEF_LogLine_tags_1)
+		/sizeof(asn_DEF_LogLine_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_LogLine_1,
 	2,	/* Elements count */
-	&asn_SPC_LogLine_1_specs	/* Additional specs */
+	&asn_SPC_LogLine_specs_1	/* Additional specs */
 };
 
 
@@ -203,7 +214,7 @@
 /*** <<< CODE [VariablePartSet] >>> ***/
 
 static int
-memb_vparts_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_vparts_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	
 	if(!sptr) {
@@ -230,13 +241,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_VariablePart,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_vparts_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_vparts_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_vparts_2_specs = {
+static asn_SET_OF_specifics_t asn_SPC_vparts_specs_2 = {
 	sizeof(struct vparts),
 	offsetof(struct vparts, _asn_ctx),
 	2,	/* XER encoding is XMLValueList */
@@ -252,16 +265,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_vparts_tags_2,
+	sizeof(asn_DEF_vparts_tags_2)
+		/sizeof(asn_DEF_vparts_tags_2[0]), /* 1 */
+	asn_DEF_vparts_tags_2,	/* Same as above */
+	sizeof(asn_DEF_vparts_tags_2)
+		/sizeof(asn_DEF_vparts_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_vparts_2,
 	1,	/* Single element */
-	&asn_SPC_vparts_2_specs	/* Additional specs */
+	&asn_SPC_vparts_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_VariablePartSet_1[] = {
@@ -269,7 +284,9 @@
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_vparts_2,
-		.memb_constraints = memb_vparts_1_constraint,
+		.memb_constraints = memb_vparts_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "vparts"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct VariablePartSet, resolution),
@@ -277,21 +294,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_ActionItem,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "resolution"
 		},
 };
-static ber_tlv_tag_t asn_DEF_VariablePartSet_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_VariablePartSet_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_VariablePartSet_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_VariablePartSet_tag2el_1[] = {
     { (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_SPC_VariablePartSet_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_VariablePartSet_specs_1 = {
 	sizeof(struct VariablePartSet),
 	offsetof(struct VariablePartSet, _asn_ctx),
-	asn_MAP_VariablePartSet_1_tag2el,
+	asn_MAP_VariablePartSet_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
 };
@@ -305,16 +325,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_VariablePartSet_tags_1,
+	sizeof(asn_DEF_VariablePartSet_tags_1)
+		/sizeof(asn_DEF_VariablePartSet_tags_1[0]), /* 1 */
+	asn_DEF_VariablePartSet_tags_1,	/* Same as above */
+	sizeof(asn_DEF_VariablePartSet_tags_1)
+		/sizeof(asn_DEF_VariablePartSet_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_VariablePartSet_1,
 	2,	/* Elements count */
-	&asn_SPC_VariablePartSet_1_specs	/* Additional specs */
+	&asn_SPC_VariablePartSet_specs_1	/* Additional specs */
 };
 
 
@@ -374,7 +396,7 @@
 /*** <<< CODE [VariablePart] >>> ***/
 
 static int
-memb_vset_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_vset_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	size_t size;
 	
@@ -408,13 +430,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_vset_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_vset_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_vset_2_specs = {
+static asn_SET_OF_specifics_t asn_SPC_vset_specs_2 = {
 	sizeof(struct vset),
 	offsetof(struct vset, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -430,16 +454,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_vset_tags_2,
+	sizeof(asn_DEF_vset_tags_2)
+		/sizeof(asn_DEF_vset_tags_2[0]), /* 1 */
+	asn_DEF_vset_tags_2,	/* Same as above */
+	sizeof(asn_DEF_vset_tags_2)
+		/sizeof(asn_DEF_vset_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_vset_2,
 	1,	/* Single element */
-	&asn_SPC_vset_2_specs	/* Additional specs */
+	&asn_SPC_vset_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_vrange_4[] = {
@@ -448,6 +474,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "from"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct vrange, to),
@@ -455,21 +483,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "to"
 		},
 };
-static ber_tlv_tag_t asn_DEF_vrange_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_vrange_tags_4[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_vrange_4_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_vrange_tag2el_4[] = {
     { (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_SPC_vrange_4_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_vrange_specs_4 = {
 	sizeof(struct vrange),
 	offsetof(struct vrange, _asn_ctx),
-	asn_MAP_vrange_4_tag2el,
+	asn_MAP_vrange_tag2el_4,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
 };
@@ -484,16 +515,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_vrange_4_tags,
-	sizeof(asn_DEF_vrange_4_tags)
-		/sizeof(asn_DEF_vrange_4_tags[0]), /* 1 */
-	asn_DEF_vrange_4_tags,	/* Same as above */
-	sizeof(asn_DEF_vrange_4_tags)
-		/sizeof(asn_DEF_vrange_4_tags[0]), /* 1 */
+	asn_DEF_vrange_tags_4,
+	sizeof(asn_DEF_vrange_tags_4)
+		/sizeof(asn_DEF_vrange_tags_4[0]), /* 1 */
+	asn_DEF_vrange_tags_4,	/* Same as above */
+	sizeof(asn_DEF_vrange_tags_4)
+		/sizeof(asn_DEF_vrange_tags_4[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_vrange_4,
 	2,	/* Elements count */
-	&asn_SPC_vrange_4_specs	/* Additional specs */
+	&asn_SPC_vrange_specs_4	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_VariablePart_1[] = {
@@ -501,7 +534,9 @@
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_vset_2,
-		.memb_constraints = memb_vset_1_constraint,
+		.memb_constraints = memb_vset_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "vset"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct VariablePart, choice.vrange),
@@ -509,21 +544,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_vrange_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "vrange"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_VariablePart_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_VariablePart_tag2el_1[] = {
     { (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_SPC_VariablePart_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_VariablePart_specs_1 = {
 	sizeof(struct VariablePart),
 	offsetof(struct VariablePart, _asn_ctx),
 	offsetof(struct VariablePart, present),
 	sizeof(((struct VariablePart *)0)->present),
-	asn_MAP_VariablePart_1_tag2el,
+	asn_MAP_VariablePart_tag2el_1,
 	2,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 2	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_VariablePart = {
 	"VariablePart",
@@ -535,14 +573,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_VariablePart_1,
 	2,	/* Elements count */
-	&asn_SPC_VariablePart_1_specs	/* Additional specs */
+	&asn_SPC_VariablePart_specs_1	/* Additional specs */
 };
 
 
@@ -622,6 +662,9 @@
 	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
 	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
 	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
 	td->elements       = asn_DEF_ENUMERATED.elements;
 	td->elements_count = asn_DEF_ENUMERATED.elements_count;
      /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
@@ -674,26 +717,26 @@
 
 /*** <<< STAT-DEFS [ActionItem] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_accept_as_2_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_accept_as_value2enum_2[] = {
 	{ 0,	7,	"unknown" },
 	{ 1,	4,	"safe" },
 	{ 2,	6,	"unsafe" }
 	/* This list is extensible */
 };
-static unsigned int asn_MAP_accept_as_2_enum2value[] = {
+static unsigned int asn_MAP_accept_as_enum2value_2[] = {
 	1,	/* safe(1) */
 	0,	/* unknown(0) */
 	2	/* unsafe(2) */
 	/* This list is extensible */
 };
-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 */
+static asn_INTEGER_specifics_t asn_SPC_accept_as_specs_2 = {
+	asn_MAP_accept_as_value2enum_2,	/* "tag" => N; sorted by tag */
+	asn_MAP_accept_as_enum2value_2,	/* N => "tag"; sorted by N */
 	3,	/* Number of elements in the maps */
-	1,	/* Enumeration is extensible */
+	4,	/* Extensions before this member */
 	1	/* Strict enumeration */
 };
-static ber_tlv_tag_t asn_DEF_accept_as_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_accept_as_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
 static /* Use -fall-defs-global to expose */
@@ -707,15 +750,17 @@
 	accept_as_2_encode_der,
 	accept_as_2_decode_xer,
 	accept_as_2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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 */
+	asn_DEF_accept_as_tags_2,
+	sizeof(asn_DEF_accept_as_tags_2)
+		/sizeof(asn_DEF_accept_as_tags_2[0]), /* 1 */
+	asn_DEF_accept_as_tags_2,	/* Same as above */
+	sizeof(asn_DEF_accept_as_tags_2)
+		/sizeof(asn_DEF_accept_as_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
-	&asn_SPC_accept_as_2_specs	/* Additional specs */
+	&asn_SPC_accept_as_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_email_9[] = {
@@ -724,13 +769,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_email_9_tags[] = {
+static ber_tlv_tag_t asn_DEF_email_tags_9[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_email_9_specs = {
+static asn_SET_OF_specifics_t asn_SPC_email_specs_9 = {
 	sizeof(struct email),
 	offsetof(struct email, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -746,16 +793,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_email_9_tags,
-	sizeof(asn_DEF_email_9_tags)
-		/sizeof(asn_DEF_email_9_tags[0]), /* 1 */
-	asn_DEF_email_9_tags,	/* Same as above */
-	sizeof(asn_DEF_email_9_tags)
-		/sizeof(asn_DEF_email_9_tags[0]), /* 1 */
+	asn_DEF_email_tags_9,
+	sizeof(asn_DEF_email_tags_9)
+		/sizeof(asn_DEF_email_tags_9[0]), /* 1 */
+	asn_DEF_email_tags_9,	/* Same as above */
+	sizeof(asn_DEF_email_tags_9)
+		/sizeof(asn_DEF_email_tags_9[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_email_9,
 	1,	/* Single element */
-	&asn_SPC_email_9_specs	/* Additional specs */
+	&asn_SPC_email_specs_9	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_notify_7[] = {
@@ -764,6 +813,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_BOOLEAN,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "critical"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct notify, email),
@@ -771,21 +822,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_email_9,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "email"
 		},
 };
-static ber_tlv_tag_t asn_DEF_notify_7_tags[] = {
+static ber_tlv_tag_t asn_DEF_notify_tags_7[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_notify_7_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_notify_tag2el_7[] = {
     { (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_SPC_notify_7_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_notify_specs_7 = {
 	sizeof(struct notify),
 	offsetof(struct notify, _asn_ctx),
-	asn_MAP_notify_7_tag2el,
+	asn_MAP_notify_tag2el_7,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
 };
@@ -800,16 +854,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_notify_7_tags,
-	sizeof(asn_DEF_notify_7_tags)
-		/sizeof(asn_DEF_notify_7_tags[0]), /* 1 */
-	asn_DEF_notify_7_tags,	/* Same as above */
-	sizeof(asn_DEF_notify_7_tags)
-		/sizeof(asn_DEF_notify_7_tags[0]), /* 1 */
+	asn_DEF_notify_tags_7,
+	sizeof(asn_DEF_notify_tags_7)
+		/sizeof(asn_DEF_notify_tags_7[0]), /* 1 */
+	asn_DEF_notify_tags_7,	/* Same as above */
+	sizeof(asn_DEF_notify_tags_7)
+		/sizeof(asn_DEF_notify_tags_7[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_notify_7,
 	2,	/* Elements count */
-	&asn_SPC_notify_7_specs	/* Additional specs */
+	&asn_SPC_notify_specs_7	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_ActionItem_1[] = {
@@ -818,6 +874,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_accept_as_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "accept-as"
 		},
 	{ ATF_POINTER, 1, offsetof(struct ActionItem, notify),
@@ -825,21 +883,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_notify_7,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "notify"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ActionItem_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_ActionItem_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_ActionItem_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ActionItem_tag2el_1[] = {
     { (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_SPC_ActionItem_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_ActionItem_specs_1 = {
 	sizeof(struct ActionItem),
 	offsetof(struct ActionItem, _asn_ctx),
-	asn_MAP_ActionItem_1_tag2el,
+	asn_MAP_ActionItem_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	1,	/* Start extensions */
 	3	/* Stop extensions */
 };
@@ -853,15 +914,17 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_ActionItem_tags_1,
+	sizeof(asn_DEF_ActionItem_tags_1)
+		/sizeof(asn_DEF_ActionItem_tags_1[0]), /* 1 */
+	asn_DEF_ActionItem_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ActionItem_tags_1)
+		/sizeof(asn_DEF_ActionItem_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_ActionItem_1,
 	2,	/* Elements count */
-	&asn_SPC_ActionItem_1_specs	/* Additional specs */
+	&asn_SPC_ActionItem_specs_1	/* Additional specs */
 };
 
diff --git a/tests/43-recursion-OK.asn1.-P b/tests/43-recursion-OK.asn1.-P
index a348036..2c4f3c7 100644
--- a/tests/43-recursion-OK.asn1.-P
+++ b/tests/43-recursion-OK.asn1.-P
@@ -50,13 +50,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Test_structure_1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_t_member1_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_t_member1_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_t_member1_2_specs = {
+static asn_SET_OF_specifics_t asn_SPC_t_member1_specs_2 = {
 	sizeof(struct t_member1),
 	offsetof(struct t_member1, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -72,16 +74,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_t_member1_tags_2,
+	sizeof(asn_DEF_t_member1_tags_2)
+		/sizeof(asn_DEF_t_member1_tags_2[0]), /* 1 */
+	asn_DEF_t_member1_tags_2,	/* Same as above */
+	sizeof(asn_DEF_t_member1_tags_2)
+		/sizeof(asn_DEF_t_member1_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_t_member1_2,
 	1,	/* Single element */
-	&asn_SPC_t_member1_2_specs	/* Additional specs */
+	&asn_SPC_t_member1_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_t_member2_4[] = {
@@ -90,13 +94,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Test_structure_1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_t_member2_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_t_member2_tags_4[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_t_member2_4_specs = {
+static asn_SET_OF_specifics_t asn_SPC_t_member2_specs_4 = {
 	sizeof(struct t_member2),
 	offsetof(struct t_member2, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -112,16 +118,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_t_member2_4_tags,
-	sizeof(asn_DEF_t_member2_4_tags)
-		/sizeof(asn_DEF_t_member2_4_tags[0]), /* 1 */
-	asn_DEF_t_member2_4_tags,	/* Same as above */
-	sizeof(asn_DEF_t_member2_4_tags)
-		/sizeof(asn_DEF_t_member2_4_tags[0]), /* 1 */
+	asn_DEF_t_member2_tags_4,
+	sizeof(asn_DEF_t_member2_tags_4)
+		/sizeof(asn_DEF_t_member2_tags_4[0]), /* 1 */
+	asn_DEF_t_member2_tags_4,	/* Same as above */
+	sizeof(asn_DEF_t_member2_tags_4)
+		/sizeof(asn_DEF_t_member2_tags_4[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_t_member2_4,
 	1,	/* Single element */
-	&asn_SPC_t_member2_4_specs	/* Additional specs */
+	&asn_SPC_t_member2_specs_4	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Test_structure_1_1[] = {
@@ -130,6 +138,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_t_member1_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "t-member1"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Test_structure_1, t_member2),
@@ -137,6 +147,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_t_member2_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "t-member2"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Test_structure_1, t_member3),
@@ -144,6 +156,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Test_structure_1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "t-member3"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Test_structure_1, t_member4),
@@ -151,23 +165,26 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "t-member4"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Test_structure_1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Test_structure_1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Test_structure_1_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Test_structure_1_tag2el_1[] = {
     { (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_SPC_Test_structure_1_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Test_structure_1_specs_1 = {
 	sizeof(struct Test_structure_1),
 	offsetof(struct Test_structure_1, _asn_ctx),
-	asn_MAP_Test_structure_1_1_tag2el,
+	asn_MAP_Test_structure_1_tag2el_1,
 	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -181,16 +198,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Test_structure_1_tags_1,
+	sizeof(asn_DEF_Test_structure_1_tags_1)
+		/sizeof(asn_DEF_Test_structure_1_tags_1[0]), /* 1 */
+	asn_DEF_Test_structure_1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Test_structure_1_tags_1)
+		/sizeof(asn_DEF_Test_structure_1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Test_structure_1_1,
 	4,	/* Elements count */
-	&asn_SPC_Test_structure_1_1_specs	/* Additional specs */
+	&asn_SPC_Test_structure_1_specs_1	/* Additional specs */
 };
 
 
@@ -251,14 +270,16 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Choice_1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_or_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_or_tags_3[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_or_3_specs = {
+static asn_SET_OF_specifics_t asn_SPC_or_specs_3 = {
 	sizeof(struct or),
 	offsetof(struct or, _asn_ctx),
 	2,	/* XER encoding is XMLValueList */
@@ -274,16 +295,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_or_3_tags,
-	sizeof(asn_DEF_or_3_tags)
-		/sizeof(asn_DEF_or_3_tags[0]) - 1, /* 1 */
-	asn_DEF_or_3_tags,	/* Same as above */
-	sizeof(asn_DEF_or_3_tags)
-		/sizeof(asn_DEF_or_3_tags[0]), /* 2 */
+	asn_DEF_or_tags_3,
+	sizeof(asn_DEF_or_tags_3)
+		/sizeof(asn_DEF_or_tags_3[0]) - 1, /* 1 */
+	asn_DEF_or_tags_3,	/* Same as above */
+	sizeof(asn_DEF_or_tags_3)
+		/sizeof(asn_DEF_or_tags_3[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_or_3,
 	1,	/* Single element */
-	&asn_SPC_or_3_specs	/* Additional specs */
+	&asn_SPC_or_specs_3	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Choice_1_1[] = {
@@ -292,6 +315,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_Choice_1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "and"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Choice_1, choice.or),
@@ -299,6 +324,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_or_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "or"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice_1, choice.not),
@@ -306,6 +333,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_Choice_1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "not"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Choice_1, choice.other),
@@ -313,23 +342,26 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "other"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice_1_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice_1_tag2el_1[] = {
     { (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_SPC_Choice_1_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice_1_specs_1 = {
 	sizeof(struct Choice_1),
 	offsetof(struct Choice_1, _asn_ctx),
 	offsetof(struct Choice_1, present),
 	sizeof(((struct Choice_1 *)0)->present),
-	asn_MAP_Choice_1_1_tag2el,
+	asn_MAP_Choice_1_tag2el_1,
 	4,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice_1 = {
 	"Choice-1",
@@ -341,14 +373,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice_1_1,
 	4,	/* Elements count */
-	&asn_SPC_Choice_1_1_specs	/* Additional specs */
+	&asn_SPC_Choice_1_specs_1	/* Additional specs */
 };
 
 
@@ -399,28 +433,30 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Test_structure_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m1"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Test_structure_2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Test_structure_2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Test_structure_2_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Test_structure_2_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* m1 at 28 */
 };
-static uint8_t asn_MAP_Test_structure_2_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Test_structure_2_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(0 << 7)
 };
-static asn_SET_specifics_t asn_SPC_Test_structure_2_1_specs = {
+static asn_SET_specifics_t asn_SPC_Test_structure_2_specs_1 = {
 	sizeof(struct Test_structure_2),
 	offsetof(struct Test_structure_2, _asn_ctx),
 	offsetof(struct Test_structure_2, _presence_map),
-	asn_MAP_Test_structure_2_1_tag2el,
+	asn_MAP_Test_structure_2_tag2el_1,
 	1,	/* Count of tags in the map */
-	asn_MAP_Test_structure_2_1_tag2el,	/* Same as above */
+	asn_MAP_Test_structure_2_tag2el_1,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_Test_structure_2_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Test_structure_2_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Test_structure_2 = {
 	"Test-structure-2",
@@ -432,16 +468,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Test_structure_2_tags_1,
+	sizeof(asn_DEF_Test_structure_2_tags_1)
+		/sizeof(asn_DEF_Test_structure_2_tags_1[0]), /* 1 */
+	asn_DEF_Test_structure_2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Test_structure_2_tags_1)
+		/sizeof(asn_DEF_Test_structure_2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Test_structure_2_1,
 	1,	/* Elements count */
-	&asn_SPC_Test_structure_2_1_specs	/* Additional specs */
+	&asn_SPC_Test_structure_2_specs_1	/* Additional specs */
 };
 
 
@@ -492,28 +530,30 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Test_structure_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m1"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Test_structure_3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Test_structure_3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Test_structure_3_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Test_structure_3_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* m1 at 29 */
 };
-static uint8_t asn_MAP_Test_structure_3_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Test_structure_3_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(0 << 7)
 };
-static asn_SET_specifics_t asn_SPC_Test_structure_3_1_specs = {
+static asn_SET_specifics_t asn_SPC_Test_structure_3_specs_1 = {
 	sizeof(struct Test_structure_3),
 	offsetof(struct Test_structure_3, _asn_ctx),
 	offsetof(struct Test_structure_3, _presence_map),
-	asn_MAP_Test_structure_3_1_tag2el,
+	asn_MAP_Test_structure_3_tag2el_1,
 	1,	/* Count of tags in the map */
-	asn_MAP_Test_structure_3_1_tag2el,	/* Same as above */
+	asn_MAP_Test_structure_3_tag2el_1,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_Test_structure_3_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Test_structure_3_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Test_structure_3 = {
 	"Test-structure-3",
@@ -525,15 +565,17 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Test_structure_3_tags_1,
+	sizeof(asn_DEF_Test_structure_3_tags_1)
+		/sizeof(asn_DEF_Test_structure_3_tags_1[0]), /* 1 */
+	asn_DEF_Test_structure_3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Test_structure_3_tags_1)
+		/sizeof(asn_DEF_Test_structure_3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Test_structure_3_1,
 	1,	/* Elements count */
-	&asn_SPC_Test_structure_3_1_specs	/* Additional specs */
+	&asn_SPC_Test_structure_3_specs_1	/* Additional specs */
 };
 
diff --git a/tests/44-choice-in-sequence-OK.asn1.-P b/tests/44-choice-in-sequence-OK.asn1.-P
index 28578ee..0121407 100644
--- a/tests/44-choice-in-sequence-OK.asn1.-P
+++ b/tests/44-choice-in-sequence-OK.asn1.-P
@@ -76,6 +76,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "f"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct e, choice.g),
@@ -83,21 +85,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "g"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_e_6_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_e_tag2el_6[] = {
     { (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_SPC_e_6_specs = {
+static asn_CHOICE_specifics_t asn_SPC_e_specs_6 = {
 	sizeof(struct e),
 	offsetof(struct e, _asn_ctx),
 	offsetof(struct e, present),
 	sizeof(((struct e *)0)->present),
-	asn_MAP_e_6_tag2el,
+	asn_MAP_e_tag2el_6,
 	2,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_e_6 = {
@@ -110,14 +115,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_e_6,
 	2,	/* Elements count */
-	&asn_SPC_e_6_specs	/* Additional specs */
+	&asn_SPC_e_specs_6	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_h_9[] = {
@@ -126,6 +133,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "i"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct h, choice.j),
@@ -133,21 +142,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "j"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_h_9_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_h_tag2el_9[] = {
     { (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_SPC_h_9_specs = {
+static asn_CHOICE_specifics_t asn_SPC_h_specs_9 = {
 	sizeof(struct h),
 	offsetof(struct h, _asn_ctx),
 	offsetof(struct h, present),
 	sizeof(((struct h *)0)->present),
-	asn_MAP_h_9_tag2el,
+	asn_MAP_h_tag2el_9,
 	2,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_h_9 = {
@@ -160,14 +172,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_h_9,
 	2,	/* Elements count */
-	&asn_SPC_h_9_specs	/* Additional specs */
+	&asn_SPC_h_specs_9	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_b_3[] = {
@@ -176,6 +190,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "c"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct b, choice.d),
@@ -183,6 +199,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "d"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct b, choice.e),
@@ -190,6 +208,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_e_6,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "e"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct b, choice.h),
@@ -197,24 +217,27 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_h_9,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "h"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_b_3_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_b_tag2el_3[] = {
     { (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_SPC_b_3_specs = {
+static asn_CHOICE_specifics_t asn_SPC_b_specs_3 = {
 	sizeof(struct b),
 	offsetof(struct b, _asn_ctx),
 	offsetof(struct b, present),
 	sizeof(((struct b *)0)->present),
-	asn_MAP_b_3_tag2el,
+	asn_MAP_b_tag2el_3,
 	5,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_b_3 = {
@@ -227,14 +250,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_b_3,
 	4,	/* Elements count */
-	&asn_SPC_b_3_specs	/* Additional specs */
+	&asn_SPC_b_specs_3	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_T_1[] = {
@@ -243,6 +268,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct T, b),
@@ -250,14 +277,16 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_b_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_PRIVATE | (1 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_tag2el_1[] = {
     { (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 */
@@ -265,11 +294,12 @@
     { (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_SPC_T_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T_specs_1 = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
-	asn_MAP_T_1_tag2el,
+	asn_MAP_T_tag2el_1,
 	6,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -283,15 +313,17 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]) - 1, /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T_1,
 	2,	/* Elements count */
-	&asn_SPC_T_1_specs	/* Additional specs */
+	&asn_SPC_T_specs_1	/* Additional specs */
 };
 
diff --git a/tests/46-redefine-OK.asn1.-PR b/tests/46-redefine-OK.asn1.-PR
index 9521de2..449707e 100644
--- a/tests/46-redefine-OK.asn1.-PR
+++ b/tests/46-redefine-OK.asn1.-PR
@@ -40,6 +40,9 @@
 	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
 	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
 	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
 	td->elements       = asn_DEF_OCTET_STRING.elements;
 	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
 	td->specifics      = asn_DEF_OCTET_STRING.specifics;
@@ -92,7 +95,7 @@
 
 /*** <<< STAT-DEFS [PrimitiveType] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_PrimitiveType_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_PrimitiveType_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_PrimitiveType = {
@@ -105,13 +108,15 @@
 	PrimitiveType_encode_der,
 	PrimitiveType_decode_xer,
 	PrimitiveType_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_PrimitiveType_1_tags,
-	sizeof(asn_DEF_PrimitiveType_1_tags)
-		/sizeof(asn_DEF_PrimitiveType_1_tags[0]), /* 1 */
-	asn_DEF_PrimitiveType_1_tags,	/* Same as above */
-	sizeof(asn_DEF_PrimitiveType_1_tags)
-		/sizeof(asn_DEF_PrimitiveType_1_tags[0]), /* 1 */
+	asn_DEF_PrimitiveType_tags_1,
+	sizeof(asn_DEF_PrimitiveType_tags_1)
+		/sizeof(asn_DEF_PrimitiveType_tags_1[0]), /* 1 */
+	asn_DEF_PrimitiveType_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PrimitiveType_tags_1)
+		/sizeof(asn_DEF_PrimitiveType_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -143,20 +148,23 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_PrimitiveType,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "field"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ConstructedType_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_ConstructedType_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_ConstructedType_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ConstructedType_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 0, 0, 0 } /* field at 18 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_ConstructedType_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_ConstructedType_specs_1 = {
 	sizeof(struct ConstructedType),
 	offsetof(struct ConstructedType, _asn_ctx),
-	asn_MAP_ConstructedType_1_tag2el,
+	asn_MAP_ConstructedType_tag2el_1,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -170,16 +178,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_ConstructedType_tags_1,
+	sizeof(asn_DEF_ConstructedType_tags_1)
+		/sizeof(asn_DEF_ConstructedType_tags_1[0]), /* 1 */
+	asn_DEF_ConstructedType_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ConstructedType_tags_1)
+		/sizeof(asn_DEF_ConstructedType_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_ConstructedType_1,
 	1,	/* Elements count */
-	&asn_SPC_ConstructedType_1_specs	/* Additional specs */
+	&asn_SPC_ConstructedType_specs_1	/* Additional specs */
 };
 
 
@@ -224,6 +234,9 @@
 	td->der_encoder    = asn_DEF_ConstructedType.der_encoder;
 	td->xer_decoder    = asn_DEF_ConstructedType.xer_decoder;
 	td->xer_encoder    = asn_DEF_ConstructedType.xer_encoder;
+	td->uper_decoder   = asn_DEF_ConstructedType.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ConstructedType.per_constraints;
 	td->elements       = asn_DEF_ConstructedType.elements;
 	td->elements_count = asn_DEF_ConstructedType.elements_count;
 	td->specifics      = asn_DEF_ConstructedType.specifics;
@@ -276,7 +289,7 @@
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
@@ -290,13 +303,15 @@
 	T_encode_der,
 	T_decode_xer,
 	T_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]) - 1, /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	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 6c04656..16863b9 100644
--- a/tests/47-set-ext-OK.asn1.-P
+++ b/tests/47-set-ext-OK.asn1.-P
@@ -43,28 +43,30 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "i"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T1_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T1_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 14 */
 };
-static uint8_t asn_MAP_T1_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_T1_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_SPC_T1_1_specs = {
+static asn_SET_specifics_t asn_SPC_T1_specs_1 = {
 	sizeof(struct T1),
 	offsetof(struct T1, _asn_ctx),
 	offsetof(struct T1, _presence_map),
-	asn_MAP_T1_1_tag2el,
+	asn_MAP_T1_tag2el_1,
 	1,	/* Count of tags in the map */
-	asn_MAP_T1_1_tag2el,	/* Same as above */
+	asn_MAP_T1_tag2el_1,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_MAP_T1_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_T1_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_T1 = {
 	"T1",
@@ -76,16 +78,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T1_tags_1,
+	sizeof(asn_DEF_T1_tags_1)
+		/sizeof(asn_DEF_T1_tags_1[0]), /* 1 */
+	asn_DEF_T1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T1_tags_1)
+		/sizeof(asn_DEF_T1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T1_1,
 	1,	/* Elements count */
-	&asn_SPC_T1_1_specs	/* Additional specs */
+	&asn_SPC_T1_specs_1	/* Additional specs */
 };
 
 
@@ -133,28 +137,30 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "i"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T2_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T2_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 15 */
 };
-static uint8_t asn_MAP_T2_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_T2_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_SPC_T2_1_specs = {
+static asn_SET_specifics_t asn_SPC_T2_specs_1 = {
 	sizeof(struct T2),
 	offsetof(struct T2, _asn_ctx),
 	offsetof(struct T2, _presence_map),
-	asn_MAP_T2_1_tag2el,
+	asn_MAP_T2_tag2el_1,
 	1,	/* Count of tags in the map */
-	asn_MAP_T2_1_tag2el,	/* Same as above */
+	asn_MAP_T2_tag2el_1,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_MAP_T2_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_T2_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_T2 = {
 	"T2",
@@ -166,16 +172,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T2_tags_1,
+	sizeof(asn_DEF_T2_tags_1)
+		/sizeof(asn_DEF_T2_tags_1[0]), /* 1 */
+	asn_DEF_T2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T2_tags_1)
+		/sizeof(asn_DEF_T2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T2_1,
 	1,	/* Elements count */
-	&asn_SPC_T2_1_specs	/* Additional specs */
+	&asn_SPC_T2_specs_1	/* Additional specs */
 };
 
 
@@ -220,20 +228,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "i"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_T3_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T3_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 16 */
 };
-static asn_CHOICE_specifics_t asn_SPC_T3_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_T3_specs_1 = {
 	sizeof(struct T3),
 	offsetof(struct T3, _asn_ctx),
 	offsetof(struct T3, present),
 	sizeof(((struct T3 *)0)->present),
-	asn_MAP_T3_1_tag2el,
+	asn_MAP_T3_tag2el_1,
 	1,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_T3 = {
 	"T3",
@@ -245,14 +256,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_T3_1,
 	1,	/* Elements count */
-	&asn_SPC_T3_1_specs	/* Additional specs */
+	&asn_SPC_T3_specs_1	/* Additional specs */
 };
 
 
@@ -297,20 +310,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "i"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_T4_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T4_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 17 */
 };
-static asn_CHOICE_specifics_t asn_SPC_T4_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_T4_specs_1 = {
 	sizeof(struct T4),
 	offsetof(struct T4, _asn_ctx),
 	offsetof(struct T4, present),
 	sizeof(((struct T4 *)0)->present),
-	asn_MAP_T4_1_tag2el,
+	asn_MAP_T4_tag2el_1,
 	1,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_T4 = {
 	"T4",
@@ -322,13 +338,15 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_T4_1,
 	1,	/* Elements count */
-	&asn_SPC_T4_1_specs	/* Additional specs */
+	&asn_SPC_T4_specs_1	/* Additional specs */
 };
 
diff --git a/tests/50-constraint-OK.asn1 b/tests/50-constraint-OK.asn1
index 85997ea..62c4fdf 100644
--- a/tests/50-constraint-OK.asn1
+++ b/tests/50-constraint-OK.asn1
@@ -16,7 +16,7 @@
 	Int1 ::= INTEGER
 	Int2 ::= Int1 (0..MAX)		-- X.680-0207::41.4.4
 	Int3 ::= Int2 (MIN..ten)	-- Means (0..10)
-	Int4 ::= Int3 (5..MAX,...,1..4)	-- Means (5..10,...,1..4)
+	Int4 ::= Int3 (5..MAX,...,1..4)	-- Means (1..10,...)
 	Int5 ::= Int4 (MIN..5)		-- Means (5)
 	-- Int6 ::= INTEGER (Int5) -- -- Not yet supported
 
@@ -52,6 +52,23 @@
 
 	VisibleIdentifier ::= Identifier
 
+	Sequence ::= SEQUENCE {
+		int1-c	Int1	(-2..MAX) DEFAULT 3,
+		int4	[2] Int4,
+		int4-c	Int4	(MIN..7),
+		bool	BOOLEAN	DEFAULT 1,
+		enum-c	ENUMERATED { one(1), two(2), ..., three(3) },
+		...,
+		int5-c	Int5 (5) OPTIONAL,
+		...,
+		null	NULL OPTIONAL
+	}
+
+	SequenceOf ::= SEQUENCE (SIZE(1..2)) OF Sequence
+
+	Enum0	::= ENUMERATED { one, two }
+	Enum1	::= ENUMERATED { one, two }	(one)
+
 END
 
 
diff --git a/tests/50-constraint-OK.asn1.-EFprint-constraints b/tests/50-constraint-OK.asn1.-EFprint-constraints
index a3adae0..2ac1285 100644
--- a/tests/50-constraint-OK.asn1.-EFprint-constraints
+++ b/tests/50-constraint-OK.asn1.-EFprint-constraints
Binary files differ
diff --git a/tests/50-constraint-OK.asn1.-P b/tests/50-constraint-OK.asn1.-P
index a3724de..18ed940 100644
--- a/tests/50-constraint-OK.asn1.-P
+++ b/tests/50-constraint-OK.asn1.-P
@@ -40,6 +40,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -92,7 +95,7 @@
 
 /*** <<< STAT-DEFS [Int1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int1 = {
@@ -105,13 +108,15 @@
 	Int1_encode_der,
 	Int1_decode_xer,
 	Int1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int1_1_tags,
-	sizeof(asn_DEF_Int1_1_tags)
-		/sizeof(asn_DEF_Int1_1_tags[0]), /* 1 */
-	asn_DEF_Int1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Int1_1_tags)
-		/sizeof(asn_DEF_Int1_1_tags[0]), /* 1 */
+	asn_DEF_Int1_tags_1,
+	sizeof(asn_DEF_Int1_tags_1)
+		/sizeof(asn_DEF_Int1_tags_1[0]), /* 1 */
+	asn_DEF_Int1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int1_tags_1)
+		/sizeof(asn_DEF_Int1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -177,6 +182,9 @@
 	td->der_encoder    = asn_DEF_Int1.der_encoder;
 	td->xer_decoder    = asn_DEF_Int1.xer_decoder;
 	td->xer_encoder    = asn_DEF_Int1.xer_encoder;
+	td->uper_decoder   = asn_DEF_Int1.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Int1.per_constraints;
 	td->elements       = asn_DEF_Int1.elements;
 	td->elements_count = asn_DEF_Int1.elements_count;
 	td->specifics      = asn_DEF_Int1.specifics;
@@ -229,7 +237,7 @@
 
 /*** <<< STAT-DEFS [Int2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int2 = {
@@ -242,13 +250,15 @@
 	Int2_encode_der,
 	Int2_decode_xer,
 	Int2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int2_1_tags,
-	sizeof(asn_DEF_Int2_1_tags)
-		/sizeof(asn_DEF_Int2_1_tags[0]), /* 1 */
-	asn_DEF_Int2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Int2_1_tags)
-		/sizeof(asn_DEF_Int2_1_tags[0]), /* 1 */
+	asn_DEF_Int2_tags_1,
+	sizeof(asn_DEF_Int2_tags_1)
+		/sizeof(asn_DEF_Int2_tags_1[0]), /* 1 */
+	asn_DEF_Int2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int2_tags_1)
+		/sizeof(asn_DEF_Int2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -318,6 +328,9 @@
 	td->der_encoder    = asn_DEF_Int2.der_encoder;
 	td->xer_decoder    = asn_DEF_Int2.xer_decoder;
 	td->xer_encoder    = asn_DEF_Int2.xer_encoder;
+	td->uper_decoder   = asn_DEF_Int2.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Int2.per_constraints;
 	td->elements       = asn_DEF_Int2.elements;
 	td->elements_count = asn_DEF_Int2.elements_count;
 	td->specifics      = asn_DEF_Int2.specifics;
@@ -370,7 +383,7 @@
 
 /*** <<< STAT-DEFS [Int3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int3 = {
@@ -383,13 +396,15 @@
 	Int3_encode_der,
 	Int3_decode_xer,
 	Int3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int3_1_tags,
-	sizeof(asn_DEF_Int3_1_tags)
-		/sizeof(asn_DEF_Int3_1_tags[0]), /* 1 */
-	asn_DEF_Int3_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Int3_1_tags)
-		/sizeof(asn_DEF_Int3_1_tags[0]), /* 1 */
+	asn_DEF_Int3_tags_1,
+	sizeof(asn_DEF_Int3_tags_1)
+		/sizeof(asn_DEF_Int3_tags_1[0]), /* 1 */
+	asn_DEF_Int3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int3_tags_1)
+		/sizeof(asn_DEF_Int3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -459,6 +474,9 @@
 	td->der_encoder    = asn_DEF_Int3.der_encoder;
 	td->xer_decoder    = asn_DEF_Int3.xer_decoder;
 	td->xer_encoder    = asn_DEF_Int3.xer_encoder;
+	td->uper_decoder   = asn_DEF_Int3.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Int3.per_constraints;
 	td->elements       = asn_DEF_Int3.elements;
 	td->elements_count = asn_DEF_Int3.elements_count;
 	td->specifics      = asn_DEF_Int3.specifics;
@@ -511,7 +529,7 @@
 
 /*** <<< STAT-DEFS [Int4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int4_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int4_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int4 = {
@@ -524,13 +542,15 @@
 	Int4_encode_der,
 	Int4_decode_xer,
 	Int4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int4_1_tags,
-	sizeof(asn_DEF_Int4_1_tags)
-		/sizeof(asn_DEF_Int4_1_tags[0]), /* 1 */
-	asn_DEF_Int4_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Int4_1_tags)
-		/sizeof(asn_DEF_Int4_1_tags[0]), /* 1 */
+	asn_DEF_Int4_tags_1,
+	sizeof(asn_DEF_Int4_tags_1)
+		/sizeof(asn_DEF_Int4_tags_1[0]), /* 1 */
+	asn_DEF_Int4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int4_tags_1)
+		/sizeof(asn_DEF_Int4_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -600,6 +620,9 @@
 	td->der_encoder    = asn_DEF_Int4.der_encoder;
 	td->xer_decoder    = asn_DEF_Int4.xer_decoder;
 	td->xer_encoder    = asn_DEF_Int4.xer_encoder;
+	td->uper_decoder   = asn_DEF_Int4.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Int4.per_constraints;
 	td->elements       = asn_DEF_Int4.elements;
 	td->elements_count = asn_DEF_Int4.elements_count;
 	td->specifics      = asn_DEF_Int4.specifics;
@@ -652,7 +675,7 @@
 
 /*** <<< STAT-DEFS [Int5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Int5_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Int5_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Int5 = {
@@ -665,13 +688,15 @@
 	Int5_encode_der,
 	Int5_decode_xer,
 	Int5_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Int5_1_tags,
-	sizeof(asn_DEF_Int5_1_tags)
-		/sizeof(asn_DEF_Int5_1_tags[0]), /* 1 */
-	asn_DEF_Int5_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Int5_1_tags)
-		/sizeof(asn_DEF_Int5_1_tags[0]), /* 1 */
+	asn_DEF_Int5_tags_1,
+	sizeof(asn_DEF_Int5_tags_1)
+		/sizeof(asn_DEF_Int5_tags_1[0]), /* 1 */
+	asn_DEF_Int5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int5_tags_1)
+		/sizeof(asn_DEF_Int5_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -741,6 +766,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -793,7 +821,7 @@
 
 /*** <<< STAT-DEFS [ExtensibleExtensions] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_ExtensibleExtensions_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_ExtensibleExtensions_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_ExtensibleExtensions = {
@@ -806,13 +834,15 @@
 	ExtensibleExtensions_encode_der,
 	ExtensibleExtensions_decode_xer,
 	ExtensibleExtensions_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ExtensibleExtensions_1_tags,
-	sizeof(asn_DEF_ExtensibleExtensions_1_tags)
-		/sizeof(asn_DEF_ExtensibleExtensions_1_tags[0]), /* 1 */
-	asn_DEF_ExtensibleExtensions_1_tags,	/* Same as above */
-	sizeof(asn_DEF_ExtensibleExtensions_1_tags)
-		/sizeof(asn_DEF_ExtensibleExtensions_1_tags[0]), /* 1 */
+	asn_DEF_ExtensibleExtensions_tags_1,
+	sizeof(asn_DEF_ExtensibleExtensions_tags_1)
+		/sizeof(asn_DEF_ExtensibleExtensions_tags_1[0]), /* 1 */
+	asn_DEF_ExtensibleExtensions_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ExtensibleExtensions_tags_1)
+		/sizeof(asn_DEF_ExtensibleExtensions_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -859,6 +889,9 @@
 	td->der_encoder    = asn_DEF_IA5String.der_encoder;
 	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
 	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
+	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_IA5String.per_constraints;
 	td->elements       = asn_DEF_IA5String.elements;
 	td->elements_count = asn_DEF_IA5String.elements_count;
 	td->specifics      = asn_DEF_IA5String.specifics;
@@ -911,7 +944,7 @@
 
 /*** <<< STAT-DEFS [Str1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Str1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Str1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Str1 = {
@@ -924,13 +957,15 @@
 	Str1_encode_der,
 	Str1_decode_xer,
 	Str1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Str1_1_tags,
-	sizeof(asn_DEF_Str1_1_tags)
-		/sizeof(asn_DEF_Str1_1_tags[0]), /* 1 */
-	asn_DEF_Str1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Str1_1_tags)
-		/sizeof(asn_DEF_Str1_1_tags[0]), /* 1 */
+	asn_DEF_Str1_tags_1,
+	sizeof(asn_DEF_Str1_tags_1)
+		/sizeof(asn_DEF_Str1_tags_1[0]), /* 1 */
+	asn_DEF_Str1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Str1_tags_1)
+		/sizeof(asn_DEF_Str1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1012,6 +1047,9 @@
 	td->der_encoder    = asn_DEF_Str1.der_encoder;
 	td->xer_decoder    = asn_DEF_Str1.xer_decoder;
 	td->xer_encoder    = asn_DEF_Str1.xer_encoder;
+	td->uper_decoder   = asn_DEF_Str1.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Str1.per_constraints;
 	td->elements       = asn_DEF_Str1.elements;
 	td->elements_count = asn_DEF_Str1.elements_count;
 	td->specifics      = asn_DEF_Str1.specifics;
@@ -1064,7 +1102,7 @@
 
 /*** <<< STAT-DEFS [Str2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Str2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Str2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Str2 = {
@@ -1077,13 +1115,15 @@
 	Str2_encode_der,
 	Str2_decode_xer,
 	Str2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Str2_1_tags,
-	sizeof(asn_DEF_Str2_1_tags)
-		/sizeof(asn_DEF_Str2_1_tags[0]), /* 1 */
-	asn_DEF_Str2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Str2_1_tags)
-		/sizeof(asn_DEF_Str2_1_tags[0]), /* 1 */
+	asn_DEF_Str2_tags_1,
+	sizeof(asn_DEF_Str2_tags_1)
+		/sizeof(asn_DEF_Str2_tags_1[0]), /* 1 */
+	asn_DEF_Str2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Str2_tags_1)
+		/sizeof(asn_DEF_Str2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1176,6 +1216,9 @@
 	td->der_encoder    = asn_DEF_Str2.der_encoder;
 	td->xer_decoder    = asn_DEF_Str2.xer_decoder;
 	td->xer_encoder    = asn_DEF_Str2.xer_encoder;
+	td->uper_decoder   = asn_DEF_Str2.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Str2.per_constraints;
 	td->elements       = asn_DEF_Str2.elements;
 	td->elements_count = asn_DEF_Str2.elements_count;
 	td->specifics      = asn_DEF_Str2.specifics;
@@ -1228,7 +1271,7 @@
 
 /*** <<< STAT-DEFS [Str3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Str3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Str3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Str3 = {
@@ -1241,13 +1284,15 @@
 	Str3_encode_der,
 	Str3_decode_xer,
 	Str3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Str3_1_tags,
-	sizeof(asn_DEF_Str3_1_tags)
-		/sizeof(asn_DEF_Str3_1_tags[0]), /* 1 */
-	asn_DEF_Str3_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Str3_1_tags)
-		/sizeof(asn_DEF_Str3_1_tags[0]), /* 1 */
+	asn_DEF_Str3_tags_1,
+	sizeof(asn_DEF_Str3_tags_1)
+		/sizeof(asn_DEF_Str3_tags_1[0]), /* 1 */
+	asn_DEF_Str3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Str3_tags_1)
+		/sizeof(asn_DEF_Str3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1326,6 +1371,9 @@
 	td->der_encoder    = asn_DEF_IA5String.der_encoder;
 	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
 	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
+	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_IA5String.per_constraints;
 	td->elements       = asn_DEF_IA5String.elements;
 	td->elements_count = asn_DEF_IA5String.elements_count;
 	td->specifics      = asn_DEF_IA5String.specifics;
@@ -1378,7 +1426,7 @@
 
 /*** <<< STAT-DEFS [Str4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Str4_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Str4_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Str4 = {
@@ -1391,13 +1439,15 @@
 	Str4_encode_der,
 	Str4_decode_xer,
 	Str4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Str4_1_tags,
-	sizeof(asn_DEF_Str4_1_tags)
-		/sizeof(asn_DEF_Str4_1_tags[0]), /* 1 */
-	asn_DEF_Str4_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Str4_1_tags)
-		/sizeof(asn_DEF_Str4_1_tags[0]), /* 1 */
+	asn_DEF_Str4_tags_1,
+	sizeof(asn_DEF_Str4_tags_1)
+		/sizeof(asn_DEF_Str4_tags_1[0]), /* 1 */
+	asn_DEF_Str4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Str4_tags_1)
+		/sizeof(asn_DEF_Str4_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1476,6 +1526,9 @@
 	td->der_encoder    = asn_DEF_IA5String.der_encoder;
 	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
 	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
+	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_IA5String.per_constraints;
 	td->elements       = asn_DEF_IA5String.elements;
 	td->elements_count = asn_DEF_IA5String.elements_count;
 	td->specifics      = asn_DEF_IA5String.specifics;
@@ -1528,7 +1581,7 @@
 
 /*** <<< STAT-DEFS [PER-Visible] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_PER_Visible_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_PER_Visible_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_PER_Visible = {
@@ -1541,13 +1594,15 @@
 	PER_Visible_encode_der,
 	PER_Visible_decode_xer,
 	PER_Visible_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_PER_Visible_1_tags,
-	sizeof(asn_DEF_PER_Visible_1_tags)
-		/sizeof(asn_DEF_PER_Visible_1_tags[0]), /* 1 */
-	asn_DEF_PER_Visible_1_tags,	/* Same as above */
-	sizeof(asn_DEF_PER_Visible_1_tags)
-		/sizeof(asn_DEF_PER_Visible_1_tags[0]), /* 1 */
+	asn_DEF_PER_Visible_tags_1,
+	sizeof(asn_DEF_PER_Visible_tags_1)
+		/sizeof(asn_DEF_PER_Visible_tags_1[0]), /* 1 */
+	asn_DEF_PER_Visible_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PER_Visible_tags_1)
+		/sizeof(asn_DEF_PER_Visible_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1626,6 +1681,9 @@
 	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
 	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
 	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
 	td->elements_count = asn_DEF_PER_Visible.elements_count;
 	td->specifics      = asn_DEF_PER_Visible.specifics;
@@ -1678,7 +1736,7 @@
 
 /*** <<< STAT-DEFS [PER-Visible-2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_PER_Visible_2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_PER_Visible_2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_PER_Visible_2 = {
@@ -1691,13 +1749,15 @@
 	PER_Visible_2_encode_der,
 	PER_Visible_2_decode_xer,
 	PER_Visible_2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_PER_Visible_2_1_tags,
-	sizeof(asn_DEF_PER_Visible_2_1_tags)
-		/sizeof(asn_DEF_PER_Visible_2_1_tags[0]), /* 1 */
-	asn_DEF_PER_Visible_2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_PER_Visible_2_1_tags)
-		/sizeof(asn_DEF_PER_Visible_2_1_tags[0]), /* 1 */
+	asn_DEF_PER_Visible_2_tags_1,
+	sizeof(asn_DEF_PER_Visible_2_tags_1)
+		/sizeof(asn_DEF_PER_Visible_2_tags_1[0]), /* 1 */
+	asn_DEF_PER_Visible_2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PER_Visible_2_tags_1)
+		/sizeof(asn_DEF_PER_Visible_2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1776,6 +1836,9 @@
 	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
 	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
 	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
 	td->elements_count = asn_DEF_PER_Visible.elements_count;
 	td->specifics      = asn_DEF_PER_Visible.specifics;
@@ -1828,7 +1891,7 @@
 
 /*** <<< STAT-DEFS [Not-PER-Visible-1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Not_PER_Visible_1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_1 = {
@@ -1841,13 +1904,15 @@
 	Not_PER_Visible_1_encode_der,
 	Not_PER_Visible_1_decode_xer,
 	Not_PER_Visible_1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Not_PER_Visible_1_1_tags,
-	sizeof(asn_DEF_Not_PER_Visible_1_1_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_1_1_tags[0]), /* 1 */
-	asn_DEF_Not_PER_Visible_1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Not_PER_Visible_1_1_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_1_1_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_1_tags_1,
+	sizeof(asn_DEF_Not_PER_Visible_1_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_1_tags_1[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_1_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1926,6 +1991,9 @@
 	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
 	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
 	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
 	td->elements_count = asn_DEF_PER_Visible.elements_count;
 	td->specifics      = asn_DEF_PER_Visible.specifics;
@@ -1978,7 +2046,7 @@
 
 /*** <<< STAT-DEFS [Not-PER-Visible-2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Not_PER_Visible_2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_2 = {
@@ -1991,13 +2059,15 @@
 	Not_PER_Visible_2_encode_der,
 	Not_PER_Visible_2_decode_xer,
 	Not_PER_Visible_2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Not_PER_Visible_2_1_tags,
-	sizeof(asn_DEF_Not_PER_Visible_2_1_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_2_1_tags[0]), /* 1 */
-	asn_DEF_Not_PER_Visible_2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Not_PER_Visible_2_1_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_2_1_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_2_tags_1,
+	sizeof(asn_DEF_Not_PER_Visible_2_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_2_tags_1[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_2_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2076,6 +2146,9 @@
 	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
 	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
 	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
 	td->elements_count = asn_DEF_PER_Visible.elements_count;
 	td->specifics      = asn_DEF_PER_Visible.specifics;
@@ -2128,7 +2201,7 @@
 
 /*** <<< STAT-DEFS [Not-PER-Visible-3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Not_PER_Visible_3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_3 = {
@@ -2141,13 +2214,15 @@
 	Not_PER_Visible_3_encode_der,
 	Not_PER_Visible_3_decode_xer,
 	Not_PER_Visible_3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Not_PER_Visible_3_1_tags,
-	sizeof(asn_DEF_Not_PER_Visible_3_1_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_3_1_tags[0]), /* 1 */
-	asn_DEF_Not_PER_Visible_3_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Not_PER_Visible_3_1_tags)
-		/sizeof(asn_DEF_Not_PER_Visible_3_1_tags[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_3_tags_1,
+	sizeof(asn_DEF_Not_PER_Visible_3_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_3_tags_1[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_3_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2229,6 +2304,9 @@
 	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
 	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
 	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
 	td->elements_count = asn_DEF_PER_Visible.elements_count;
 	td->specifics      = asn_DEF_PER_Visible.specifics;
@@ -2281,7 +2359,7 @@
 
 /*** <<< STAT-DEFS [SIZE-but-not-FROM] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_SIZE_but_not_FROM_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SIZE_but_not_FROM_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_SIZE_but_not_FROM = {
@@ -2294,13 +2372,15 @@
 	SIZE_but_not_FROM_encode_der,
 	SIZE_but_not_FROM_decode_xer,
 	SIZE_but_not_FROM_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SIZE_but_not_FROM_1_tags,
-	sizeof(asn_DEF_SIZE_but_not_FROM_1_tags)
-		/sizeof(asn_DEF_SIZE_but_not_FROM_1_tags[0]), /* 1 */
-	asn_DEF_SIZE_but_not_FROM_1_tags,	/* Same as above */
-	sizeof(asn_DEF_SIZE_but_not_FROM_1_tags)
-		/sizeof(asn_DEF_SIZE_but_not_FROM_1_tags[0]), /* 1 */
+	asn_DEF_SIZE_but_not_FROM_tags_1,
+	sizeof(asn_DEF_SIZE_but_not_FROM_tags_1)
+		/sizeof(asn_DEF_SIZE_but_not_FROM_tags_1[0]), /* 1 */
+	asn_DEF_SIZE_but_not_FROM_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SIZE_but_not_FROM_tags_1)
+		/sizeof(asn_DEF_SIZE_but_not_FROM_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2382,6 +2462,9 @@
 	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
 	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
 	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
 	td->elements_count = asn_DEF_PER_Visible.elements_count;
 	td->specifics      = asn_DEF_PER_Visible.specifics;
@@ -2434,7 +2517,7 @@
 
 /*** <<< STAT-DEFS [SIZE-and-FROM] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_SIZE_and_FROM_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SIZE_and_FROM_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_SIZE_and_FROM = {
@@ -2447,13 +2530,15 @@
 	SIZE_and_FROM_encode_der,
 	SIZE_and_FROM_decode_xer,
 	SIZE_and_FROM_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SIZE_and_FROM_1_tags,
-	sizeof(asn_DEF_SIZE_and_FROM_1_tags)
-		/sizeof(asn_DEF_SIZE_and_FROM_1_tags[0]), /* 1 */
-	asn_DEF_SIZE_and_FROM_1_tags,	/* Same as above */
-	sizeof(asn_DEF_SIZE_and_FROM_1_tags)
-		/sizeof(asn_DEF_SIZE_and_FROM_1_tags[0]), /* 1 */
+	asn_DEF_SIZE_and_FROM_tags_1,
+	sizeof(asn_DEF_SIZE_and_FROM_tags_1)
+		/sizeof(asn_DEF_SIZE_and_FROM_tags_1[0]), /* 1 */
+	asn_DEF_SIZE_and_FROM_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SIZE_and_FROM_tags_1)
+		/sizeof(asn_DEF_SIZE_and_FROM_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2532,6 +2617,9 @@
 	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
 	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
 	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
 	td->elements_count = asn_DEF_PER_Visible.elements_count;
 	td->specifics      = asn_DEF_PER_Visible.specifics;
@@ -2584,7 +2672,7 @@
 
 /*** <<< STAT-DEFS [Neither-SIZE-nor-FROM] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Neither_SIZE_nor_FROM_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Neither_SIZE_nor_FROM_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Neither_SIZE_nor_FROM = {
@@ -2597,13 +2685,15 @@
 	Neither_SIZE_nor_FROM_encode_der,
 	Neither_SIZE_nor_FROM_decode_xer,
 	Neither_SIZE_nor_FROM_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Neither_SIZE_nor_FROM_1_tags,
-	sizeof(asn_DEF_Neither_SIZE_nor_FROM_1_tags)
-		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_1_tags[0]), /* 1 */
-	asn_DEF_Neither_SIZE_nor_FROM_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Neither_SIZE_nor_FROM_1_tags)
-		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_1_tags[0]), /* 1 */
+	asn_DEF_Neither_SIZE_nor_FROM_tags_1,
+	sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1)
+		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1[0]), /* 1 */
+	asn_DEF_Neither_SIZE_nor_FROM_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1)
+		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2676,6 +2766,9 @@
 	td->der_encoder    = asn_DEF_UTF8String.der_encoder;
 	td->xer_decoder    = asn_DEF_UTF8String.xer_decoder;
 	td->xer_encoder    = asn_DEF_UTF8String.xer_encoder;
+	td->uper_decoder   = asn_DEF_UTF8String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_UTF8String.per_constraints;
 	td->elements       = asn_DEF_UTF8String.elements;
 	td->elements_count = asn_DEF_UTF8String.elements_count;
 	td->specifics      = asn_DEF_UTF8String.specifics;
@@ -2728,7 +2821,7 @@
 
 /*** <<< STAT-DEFS [Utf8-4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Utf8_4_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Utf8_4_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Utf8_4 = {
@@ -2741,13 +2834,15 @@
 	Utf8_4_encode_der,
 	Utf8_4_decode_xer,
 	Utf8_4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Utf8_4_1_tags,
-	sizeof(asn_DEF_Utf8_4_1_tags)
-		/sizeof(asn_DEF_Utf8_4_1_tags[0]), /* 1 */
-	asn_DEF_Utf8_4_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Utf8_4_1_tags)
-		/sizeof(asn_DEF_Utf8_4_1_tags[0]), /* 1 */
+	asn_DEF_Utf8_4_tags_1,
+	sizeof(asn_DEF_Utf8_4_tags_1)
+		/sizeof(asn_DEF_Utf8_4_tags_1[0]), /* 1 */
+	asn_DEF_Utf8_4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Utf8_4_tags_1)
+		/sizeof(asn_DEF_Utf8_4_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2848,6 +2943,9 @@
 	td->der_encoder    = asn_DEF_Utf8_2.der_encoder;
 	td->xer_decoder    = asn_DEF_Utf8_2.xer_decoder;
 	td->xer_encoder    = asn_DEF_Utf8_2.xer_encoder;
+	td->uper_decoder   = asn_DEF_Utf8_2.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Utf8_2.per_constraints;
 	td->elements       = asn_DEF_Utf8_2.elements;
 	td->elements_count = asn_DEF_Utf8_2.elements_count;
 	td->specifics      = asn_DEF_Utf8_2.specifics;
@@ -2900,7 +2998,7 @@
 
 /*** <<< STAT-DEFS [Utf8-3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Utf8_3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Utf8_3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Utf8_3 = {
@@ -2913,13 +3011,15 @@
 	Utf8_3_encode_der,
 	Utf8_3_decode_xer,
 	Utf8_3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Utf8_3_1_tags,
-	sizeof(asn_DEF_Utf8_3_1_tags)
-		/sizeof(asn_DEF_Utf8_3_1_tags[0]), /* 1 */
-	asn_DEF_Utf8_3_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Utf8_3_1_tags)
-		/sizeof(asn_DEF_Utf8_3_1_tags[0]), /* 1 */
+	asn_DEF_Utf8_3_tags_1,
+	sizeof(asn_DEF_Utf8_3_tags_1)
+		/sizeof(asn_DEF_Utf8_3_tags_1[0]), /* 1 */
+	asn_DEF_Utf8_3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Utf8_3_tags_1)
+		/sizeof(asn_DEF_Utf8_3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2990,6 +3090,9 @@
 	td->der_encoder    = asn_DEF_Utf8_1.der_encoder;
 	td->xer_decoder    = asn_DEF_Utf8_1.xer_decoder;
 	td->xer_encoder    = asn_DEF_Utf8_1.xer_encoder;
+	td->uper_decoder   = asn_DEF_Utf8_1.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Utf8_1.per_constraints;
 	td->elements       = asn_DEF_Utf8_1.elements;
 	td->elements_count = asn_DEF_Utf8_1.elements_count;
 	td->specifics      = asn_DEF_Utf8_1.specifics;
@@ -3042,7 +3145,7 @@
 
 /*** <<< STAT-DEFS [Utf8-2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Utf8_2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Utf8_2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Utf8_2 = {
@@ -3055,13 +3158,15 @@
 	Utf8_2_encode_der,
 	Utf8_2_decode_xer,
 	Utf8_2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Utf8_2_1_tags,
-	sizeof(asn_DEF_Utf8_2_1_tags)
-		/sizeof(asn_DEF_Utf8_2_1_tags[0]), /* 1 */
-	asn_DEF_Utf8_2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Utf8_2_1_tags)
-		/sizeof(asn_DEF_Utf8_2_1_tags[0]), /* 1 */
+	asn_DEF_Utf8_2_tags_1,
+	sizeof(asn_DEF_Utf8_2_tags_1)
+		/sizeof(asn_DEF_Utf8_2_tags_1[0]), /* 1 */
+	asn_DEF_Utf8_2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Utf8_2_tags_1)
+		/sizeof(asn_DEF_Utf8_2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -3108,6 +3213,9 @@
 	td->der_encoder    = asn_DEF_UTF8String.der_encoder;
 	td->xer_decoder    = asn_DEF_UTF8String.xer_decoder;
 	td->xer_encoder    = asn_DEF_UTF8String.xer_encoder;
+	td->uper_decoder   = asn_DEF_UTF8String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_UTF8String.per_constraints;
 	td->elements       = asn_DEF_UTF8String.elements;
 	td->elements_count = asn_DEF_UTF8String.elements_count;
 	td->specifics      = asn_DEF_UTF8String.specifics;
@@ -3160,7 +3268,7 @@
 
 /*** <<< STAT-DEFS [Utf8-1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Utf8_1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Utf8_1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Utf8_1 = {
@@ -3173,13 +3281,15 @@
 	Utf8_1_encode_der,
 	Utf8_1_decode_xer,
 	Utf8_1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Utf8_1_1_tags,
-	sizeof(asn_DEF_Utf8_1_1_tags)
-		/sizeof(asn_DEF_Utf8_1_1_tags[0]), /* 1 */
-	asn_DEF_Utf8_1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Utf8_1_1_tags)
-		/sizeof(asn_DEF_Utf8_1_1_tags[0]), /* 1 */
+	asn_DEF_Utf8_1_tags_1,
+	sizeof(asn_DEF_Utf8_1_tags_1)
+		/sizeof(asn_DEF_Utf8_1_tags_1[0]), /* 1 */
+	asn_DEF_Utf8_1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Utf8_1_tags_1)
+		/sizeof(asn_DEF_Utf8_1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -3273,6 +3383,9 @@
 	td->der_encoder    = asn_DEF_Identifier.der_encoder;
 	td->xer_decoder    = asn_DEF_Identifier.xer_decoder;
 	td->xer_encoder    = asn_DEF_Identifier.xer_encoder;
+	td->uper_decoder   = asn_DEF_Identifier.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Identifier.per_constraints;
 	td->elements       = asn_DEF_Identifier.elements;
 	td->elements_count = asn_DEF_Identifier.elements_count;
 	td->specifics      = asn_DEF_Identifier.specifics;
@@ -3325,7 +3438,7 @@
 
 /*** <<< STAT-DEFS [VisibleIdentifier] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_VisibleIdentifier_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_VisibleIdentifier_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (26 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_VisibleIdentifier = {
@@ -3338,18 +3451,794 @@
 	VisibleIdentifier_encode_der,
 	VisibleIdentifier_decode_xer,
 	VisibleIdentifier_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_VisibleIdentifier_1_tags,
-	sizeof(asn_DEF_VisibleIdentifier_1_tags)
-		/sizeof(asn_DEF_VisibleIdentifier_1_tags[0]), /* 1 */
-	asn_DEF_VisibleIdentifier_1_tags,	/* Same as above */
-	sizeof(asn_DEF_VisibleIdentifier_1_tags)
-		/sizeof(asn_DEF_VisibleIdentifier_1_tags[0]), /* 1 */
+	asn_DEF_VisibleIdentifier_tags_1,
+	sizeof(asn_DEF_VisibleIdentifier_tags_1)
+		/sizeof(asn_DEF_VisibleIdentifier_tags_1[0]), /* 1 */
+	asn_DEF_VisibleIdentifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_VisibleIdentifier_tags_1)
+		/sizeof(asn_DEF_VisibleIdentifier_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
 
 
+/*** <<< INCLUDES [Sequence] >>> ***/
+
+#include <Int1.h>
+#include <Int4.h>
+#include <BOOLEAN.h>
+#include <ENUMERATED.h>
+#include <NULL.h>
+#include <Int5.h>
+#include <constr_SEQUENCE.h>
+
+/*** <<< DEPS [Sequence] >>> ***/
+
+typedef enum enum_c {
+	enum_c_one	= 1,
+	enum_c_two	= 2,
+	/*
+	 * Enumeration is extensible
+	 */
+	enum_c_three	= 3
+} enum_c_e;
+
+/*** <<< TYPE-DECLS [Sequence] >>> ***/
+
+typedef struct Sequence {
+	Int1_t	*int1_c	/* DEFAULT 3 */;
+	Int4_t	 int4;
+	Int4_t	 int4_c;
+	BOOLEAN_t	*bool	/* DEFAULT 1 */;
+	ENUMERATED_t	 enum_c;
+	NULL_t	*null	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	Int5_t	*int5_c	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Sequence_t;
+
+/*** <<< FUNC-DECLS [Sequence] >>> ***/
+
+/* extern asn_TYPE_descriptor_t asn_DEF_enum_c_6;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_Sequence;
+
+/*** <<< CODE [Sequence] >>> ***/
+
+static int
+enum_c_6_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;
+	return td->check_constraints(td, sptr, app_errlog, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+enum_c_6_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;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+static void
+enum_c_6_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+static int
+enum_c_6_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+static asn_dec_rval_t
+enum_c_6_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+static asn_enc_rval_t
+enum_c_6_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) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+static asn_dec_rval_t
+enum_c_6_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+static asn_enc_rval_t
+enum_c_6_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) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static int
+memb_int1_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int1_t *st = (const Int1_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= -2)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_int4_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int4_t *st = (const Int4_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 5 && value <= 7)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_int5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int5_t *st = (const Int5_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value == 5)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+
+/*** <<< STAT-DEFS [Sequence] >>> ***/
+
+static int asn_DFL_2_set_3(void **sptr) {
+	Int1_t *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 3 */
+	return asn_long2INTEGER(st, 3);
+}
+static int asn_DFL_5_set_1(void **sptr) {
+	BOOLEAN_t *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 1 */
+	*st = 1;
+	return 0;
+}
+static asn_INTEGER_enum_map_t asn_MAP_enum_c_value2enum_6[] = {
+	{ 1,	3,	"one" },
+	{ 2,	3,	"two" },
+	{ 3,	5,	"three" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_enum_c_enum2value_6[] = {
+	0,	/* one(1) */
+	2,	/* three(3) */
+	1	/* two(2) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_enum_c_specs_6 = {
+	asn_MAP_enum_c_value2enum_6,	/* "tag" => N; sorted by tag */
+	asn_MAP_enum_c_enum2value_6,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1	/* Strict enumeration */
+};
+static ber_tlv_tag_t asn_DEF_enum_c_tags_6[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_enum_c_6 = {
+	"enum-c",
+	"enum-c",
+	enum_c_6_free,
+	enum_c_6_print,
+	enum_c_6_constraint,
+	enum_c_6_decode_ber,
+	enum_c_6_encode_der,
+	enum_c_6_decode_xer,
+	enum_c_6_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_enum_c_tags_6,
+	sizeof(asn_DEF_enum_c_tags_6)
+		/sizeof(asn_DEF_enum_c_tags_6[0]), /* 1 */
+	asn_DEF_enum_c_tags_6,	/* Same as above */
+	sizeof(asn_DEF_enum_c_tags_6)
+		/sizeof(asn_DEF_enum_c_tags_6[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_enum_c_specs_6	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_Sequence_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct Sequence, int1_c),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Int1,
+		.memb_constraints = memb_int1_c_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = asn_DFL_2_set_3,	/* DEFAULT 3 */
+		.name = "int1-c"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Sequence, int4),
+		.tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		.tag_mode = +1,	/* EXPLICIT tag at current level */
+		.type = &asn_DEF_Int4,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "int4"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Sequence, int4_c),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Int4,
+		.memb_constraints = memb_int4_c_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "int4-c"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Sequence, bool),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_BOOLEAN,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = asn_DFL_5_set_1,	/* DEFAULT 1 */
+		.name = "bool"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Sequence, enum_c),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_enum_c_6,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "enum-c"
+		},
+	{ ATF_POINTER, 2, offsetof(struct Sequence, null),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_NULL,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "null"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Sequence, int5_c),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Int5,
+		.memb_constraints = memb_int5_c_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "int5-c"
+		},
+};
+static ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 3, 0, 0 }, /* bool at 59 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 2 }, /* int1-c at 56 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 1 }, /* int4-c at 58 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 6, -2, 0 }, /* int5-c at 62 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 5, 0, 0 }, /* null at 64 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 4, 0, 0 }, /* enum-c at 60 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 } /* int4 at 57 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
+	sizeof(struct Sequence),
+	offsetof(struct Sequence, _asn_ctx),
+	asn_MAP_Sequence_tag2el_1,
+	7,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	5,	/* Start extensions */
+	8	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Sequence = {
+	"Sequence",
+	"Sequence",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Sequence_tags_1,
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	asn_DEF_Sequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Sequence_1,
+	7,	/* Elements count */
+	&asn_SPC_Sequence_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [SequenceOf] >>> ***/
+
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+/*** <<< FWD-DECLS [SequenceOf] >>> ***/
+
+struct Sequence;
+
+/*** <<< TYPE-DECLS [SequenceOf] >>> ***/
+
+typedef struct SequenceOf {
+	A_SEQUENCE_OF(struct Sequence) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} SequenceOf_t;
+
+/*** <<< FUNC-DECLS [SequenceOf] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_SequenceOf;
+
+/*** <<< POST-INCLUDE [SequenceOf] >>> ***/
+
+#include <Sequence.h>
+
+/*** <<< STAT-DEFS [SequenceOf] >>> ***/
+
+static asn_TYPE_member_t asn_MBR_SequenceOf_1[] = {
+	{ ATF_POINTER, 0, 0,
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Sequence,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = ""
+		},
+};
+static ber_tlv_tag_t asn_DEF_SequenceOf_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SequenceOf_specs_1 = {
+	sizeof(struct SequenceOf),
+	offsetof(struct SequenceOf, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SequenceOf = {
+	"SequenceOf",
+	"SequenceOf",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SequenceOf_tags_1,
+	sizeof(asn_DEF_SequenceOf_tags_1)
+		/sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */
+	asn_DEF_SequenceOf_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SequenceOf_tags_1)
+		/sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SequenceOf_1,
+	1,	/* Single element */
+	&asn_SPC_SequenceOf_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Enum0] >>> ***/
+
+#include <ENUMERATED.h>
+
+/*** <<< DEPS [Enum0] >>> ***/
+
+typedef enum Enum0 {
+	Enum0_one	= 0,
+	Enum0_two	= 1
+} Enum0_e;
+
+/*** <<< TYPE-DECLS [Enum0] >>> ***/
+
+typedef ENUMERATED_t	 Enum0_t;
+
+/*** <<< FUNC-DECLS [Enum0] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum0;
+asn_struct_free_f Enum0_free;
+asn_struct_print_f Enum0_print;
+asn_constr_check_f Enum0_constraint;
+ber_type_decoder_f Enum0_decode_ber;
+der_type_encoder_f Enum0_encode_der;
+xer_type_decoder_f Enum0_decode_xer;
+xer_type_encoder_f Enum0_encode_xer;
+
+/*** <<< CODE [Enum0] >>> ***/
+
+int
+Enum0_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;
+	return td->check_constraints(td, sptr, app_errlog, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum0_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;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+Enum0_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum0_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum0_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum0_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) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum0_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum0_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) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [Enum0] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum0_value2enum_1[] = {
+	{ 0,	3,	"one" },
+	{ 1,	3,	"two" }
+};
+static unsigned int asn_MAP_Enum0_enum2value_1[] = {
+	0,	/* one(0) */
+	1	/* two(1) */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum0_specs_1 = {
+	asn_MAP_Enum0_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum0_enum2value_1,	/* 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_Enum0_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Enum0 = {
+	"Enum0",
+	"Enum0",
+	Enum0_free,
+	Enum0_print,
+	Enum0_constraint,
+	Enum0_decode_ber,
+	Enum0_encode_der,
+	Enum0_decode_xer,
+	Enum0_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum0_tags_1,
+	sizeof(asn_DEF_Enum0_tags_1)
+		/sizeof(asn_DEF_Enum0_tags_1[0]), /* 1 */
+	asn_DEF_Enum0_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum0_tags_1)
+		/sizeof(asn_DEF_Enum0_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum0_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Enum1] >>> ***/
+
+#include <NativeEnumerated.h>
+
+/*** <<< DEPS [Enum1] >>> ***/
+
+typedef enum Enum1 {
+	Enum1_one	= 0,
+	Enum1_two	= 1
+} Enum1_e;
+
+/*** <<< TYPE-DECLS [Enum1] >>> ***/
+
+typedef long	 Enum1_t;
+
+/*** <<< FUNC-DECLS [Enum1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum1;
+asn_struct_free_f Enum1_free;
+asn_struct_print_f Enum1_print;
+asn_constr_check_f Enum1_constraint;
+ber_type_decoder_f Enum1_decode_ber;
+der_type_encoder_f Enum1_encode_der;
+xer_type_decoder_f Enum1_decode_xer;
+xer_type_encoder_f Enum1_encode_xer;
+
+/*** <<< CODE [Enum1] >>> ***/
+
+int
+Enum1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value == 0)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+Enum1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum1_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) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum1_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) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [Enum1] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum1_value2enum_1[] = {
+	{ 0,	3,	"one" },
+	{ 1,	3,	"two" }
+};
+static unsigned int asn_MAP_Enum1_enum2value_1[] = {
+	0,	/* one(0) */
+	1	/* two(1) */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum1_specs_1 = {
+	asn_MAP_Enum1_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum1_enum2value_1,	/* 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_Enum1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Enum1 = {
+	"Enum1",
+	"Enum1",
+	Enum1_free,
+	Enum1_print,
+	Enum1_constraint,
+	Enum1_decode_ber,
+	Enum1_encode_der,
+	Enum1_decode_xer,
+	Enum1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum1_tags_1,
+	sizeof(asn_DEF_Enum1_tags_1)
+		/sizeof(asn_DEF_Enum1_tags_1[0]), /* 1 */
+	asn_DEF_Enum1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum1_tags_1)
+		/sizeof(asn_DEF_Enum1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum1_specs_1	/* Additional specs */
+};
+
+
 /*** <<< INCLUDES [Identifier] >>> ***/
 
 #include <VisibleString.h>
@@ -3438,6 +4327,9 @@
 	td->der_encoder    = asn_DEF_VisibleString.der_encoder;
 	td->xer_decoder    = asn_DEF_VisibleString.xer_decoder;
 	td->xer_encoder    = asn_DEF_VisibleString.xer_encoder;
+	td->uper_decoder   = asn_DEF_VisibleString.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_VisibleString.per_constraints;
 	td->elements       = asn_DEF_VisibleString.elements;
 	td->elements_count = asn_DEF_VisibleString.elements_count;
 	td->specifics      = asn_DEF_VisibleString.specifics;
@@ -3490,7 +4382,7 @@
 
 /*** <<< STAT-DEFS [Identifier] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_Identifier_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Identifier_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (26 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_Identifier = {
@@ -3503,13 +4395,15 @@
 	Identifier_encode_der,
 	Identifier_decode_xer,
 	Identifier_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Identifier_1_tags,
-	sizeof(asn_DEF_Identifier_1_tags)
-		/sizeof(asn_DEF_Identifier_1_tags[0]), /* 1 */
-	asn_DEF_Identifier_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Identifier_1_tags)
-		/sizeof(asn_DEF_Identifier_1_tags[0]), /* 1 */
+	asn_DEF_Identifier_tags_1,
+	sizeof(asn_DEF_Identifier_tags_1)
+		/sizeof(asn_DEF_Identifier_tags_1[0]), /* 1 */
+	asn_DEF_Identifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Identifier_tags_1)
+		/sizeof(asn_DEF_Identifier_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
diff --git a/tests/50-constraint-OK.asn1.-Pgen-PER b/tests/50-constraint-OK.asn1.-Pgen-PER
new file mode 100644
index 0000000..a5c37ad
--- /dev/null
+++ b/tests/50-constraint-OK.asn1.-Pgen-PER
@@ -0,0 +1,4739 @@
+
+/*** <<< INCLUDES [Int1] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [Int1] >>> ***/
+
+typedef INTEGER_t	 Int1_t;
+
+/*** <<< FUNC-DECLS [Int1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Int1;
+asn_struct_free_f Int1_free;
+asn_struct_print_f Int1_print;
+asn_constr_check_f Int1_constraint;
+ber_type_decoder_f Int1_decode_ber;
+der_type_encoder_f Int1_encode_der;
+xer_type_decoder_f Int1_decode_xer;
+xer_type_encoder_f Int1_encode_xer;
+per_type_decoder_f Int1_decode_uper;
+
+/*** <<< CODE [Int1] >>> ***/
+
+int
+Int1_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
+Int1_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+Int1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Int1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Int1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Int1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Int1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Int1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Int1_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) {
+	Int1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Int1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Int1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Int1_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) {
+	Int1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Int1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Int1_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Int1] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Int1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Int1 = {
+	"Int1",
+	"Int1",
+	Int1_free,
+	Int1_print,
+	Int1_constraint,
+	Int1_decode_ber,
+	Int1_encode_der,
+	Int1_decode_xer,
+	Int1_encode_xer,
+	Int1_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Int1_tags_1,
+	sizeof(asn_DEF_Int1_tags_1)
+		/sizeof(asn_DEF_Int1_tags_1[0]), /* 1 */
+	asn_DEF_Int1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int1_tags_1)
+		/sizeof(asn_DEF_Int1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Int2] >>> ***/
+
+#include <Int1.h>
+
+/*** <<< TYPE-DECLS [Int2] >>> ***/
+
+typedef Int1_t	 Int2_t;
+
+/*** <<< FUNC-DECLS [Int2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Int2;
+asn_struct_free_f Int2_free;
+asn_struct_print_f Int2_print;
+asn_constr_check_f Int2_constraint;
+ber_type_decoder_f Int2_decode_ber;
+der_type_encoder_f Int2_encode_der;
+xer_type_decoder_f Int2_decode_xer;
+xer_type_encoder_f Int2_encode_xer;
+per_type_decoder_f Int2_decode_uper;
+
+/*** <<< CODE [Int2] >>> ***/
+
+int
+Int2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int1_t *st = (const Int1_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Check if the sign bit is present */
+	value = st->buf ? ((st->buf[0] & 0x80) ? -1 : 1) : 0;
+	
+	if((value >= 0)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Int1,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Int2_1_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;
+	td->der_encoder    = asn_DEF_Int1.der_encoder;
+	td->xer_decoder    = asn_DEF_Int1.xer_decoder;
+	td->xer_encoder    = asn_DEF_Int1.xer_encoder;
+	td->uper_decoder   = asn_DEF_Int1.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Int1.per_constraints;
+	td->elements       = asn_DEF_Int1.elements;
+	td->elements_count = asn_DEF_Int1.elements_count;
+	td->specifics      = asn_DEF_Int1.specifics;
+}
+
+void
+Int2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Int2_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Int2_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Int2_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Int2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Int2_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Int2] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Int2_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_Int2_constr_1 = {
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  0,  0 }	/* (0..MAX) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Int2 = {
+	"Int2",
+	"Int2",
+	Int2_free,
+	Int2_print,
+	Int2_constraint,
+	Int2_decode_ber,
+	Int2_encode_der,
+	Int2_decode_xer,
+	Int2_encode_xer,
+	Int2_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Int2_tags_1,
+	sizeof(asn_DEF_Int2_tags_1)
+		/sizeof(asn_DEF_Int2_tags_1[0]), /* 1 */
+	asn_DEF_Int2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int2_tags_1)
+		/sizeof(asn_DEF_Int2_tags_1[0]), /* 1 */
+	&asn_PER_Int2_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Int3] >>> ***/
+
+#include <Int2.h>
+
+/*** <<< TYPE-DECLS [Int3] >>> ***/
+
+typedef Int2_t	 Int3_t;
+
+/*** <<< FUNC-DECLS [Int3] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Int3;
+asn_struct_free_f Int3_free;
+asn_struct_print_f Int3_print;
+asn_constr_check_f Int3_constraint;
+ber_type_decoder_f Int3_decode_ber;
+der_type_encoder_f Int3_encode_der;
+xer_type_decoder_f Int3_decode_xer;
+xer_type_encoder_f Int3_encode_xer;
+per_type_decoder_f Int3_decode_uper;
+
+/*** <<< CODE [Int3] >>> ***/
+
+int
+Int3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int2_t *st = (const Int2_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 0 && value <= 10)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Int2,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Int3_1_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;
+	td->der_encoder    = asn_DEF_Int2.der_encoder;
+	td->xer_decoder    = asn_DEF_Int2.xer_decoder;
+	td->xer_encoder    = asn_DEF_Int2.xer_encoder;
+	td->uper_decoder   = asn_DEF_Int2.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Int2.per_constraints;
+	td->elements       = asn_DEF_Int2.elements;
+	td->elements_count = asn_DEF_Int2.elements_count;
+	td->specifics      = asn_DEF_Int2.specifics;
+}
+
+void
+Int3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Int3_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Int3_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Int3_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Int3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Int3_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Int3] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Int3_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_Int3_constr_1 = {
+	{ APC_CONSTRAINED,	 4,  4,  0,  10 }	/* (0..10) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Int3 = {
+	"Int3",
+	"Int3",
+	Int3_free,
+	Int3_print,
+	Int3_constraint,
+	Int3_decode_ber,
+	Int3_encode_der,
+	Int3_decode_xer,
+	Int3_encode_xer,
+	Int3_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Int3_tags_1,
+	sizeof(asn_DEF_Int3_tags_1)
+		/sizeof(asn_DEF_Int3_tags_1[0]), /* 1 */
+	asn_DEF_Int3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int3_tags_1)
+		/sizeof(asn_DEF_Int3_tags_1[0]), /* 1 */
+	&asn_PER_Int3_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Int4] >>> ***/
+
+#include <Int3.h>
+
+/*** <<< TYPE-DECLS [Int4] >>> ***/
+
+typedef Int3_t	 Int4_t;
+
+/*** <<< FUNC-DECLS [Int4] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Int4;
+asn_struct_free_f Int4_free;
+asn_struct_print_f Int4_print;
+asn_constr_check_f Int4_constraint;
+ber_type_decoder_f Int4_decode_ber;
+der_type_encoder_f Int4_encode_der;
+xer_type_decoder_f Int4_decode_xer;
+xer_type_encoder_f Int4_encode_xer;
+per_type_decoder_f Int4_decode_uper;
+
+/*** <<< CODE [Int4] >>> ***/
+
+int
+Int4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int3_t *st = (const Int3_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 1 && value <= 10)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Int3,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Int4_1_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;
+	td->der_encoder    = asn_DEF_Int3.der_encoder;
+	td->xer_decoder    = asn_DEF_Int3.xer_decoder;
+	td->xer_encoder    = asn_DEF_Int3.xer_encoder;
+	td->uper_decoder   = asn_DEF_Int3.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Int3.per_constraints;
+	td->elements       = asn_DEF_Int3.elements;
+	td->elements_count = asn_DEF_Int3.elements_count;
+	td->specifics      = asn_DEF_Int3.specifics;
+}
+
+void
+Int4_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Int4_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Int4_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Int4_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Int4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Int4_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Int4] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Int4_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_Int4_constr_1 = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  4,  4,  1,  10 }	/* (1..10,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Int4 = {
+	"Int4",
+	"Int4",
+	Int4_free,
+	Int4_print,
+	Int4_constraint,
+	Int4_decode_ber,
+	Int4_encode_der,
+	Int4_decode_xer,
+	Int4_encode_xer,
+	Int4_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Int4_tags_1,
+	sizeof(asn_DEF_Int4_tags_1)
+		/sizeof(asn_DEF_Int4_tags_1[0]), /* 1 */
+	asn_DEF_Int4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int4_tags_1)
+		/sizeof(asn_DEF_Int4_tags_1[0]), /* 1 */
+	&asn_PER_Int4_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Int5] >>> ***/
+
+#include <Int4.h>
+
+/*** <<< TYPE-DECLS [Int5] >>> ***/
+
+typedef Int4_t	 Int5_t;
+
+/*** <<< FUNC-DECLS [Int5] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Int5;
+asn_struct_free_f Int5_free;
+asn_struct_print_f Int5_print;
+asn_constr_check_f Int5_constraint;
+ber_type_decoder_f Int5_decode_ber;
+der_type_encoder_f Int5_encode_der;
+xer_type_decoder_f Int5_decode_xer;
+xer_type_encoder_f Int5_encode_xer;
+per_type_decoder_f Int5_decode_uper;
+
+/*** <<< CODE [Int5] >>> ***/
+
+int
+Int5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int4_t *st = (const Int4_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value == 5)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Int4,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Int5_1_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;
+	td->der_encoder    = asn_DEF_Int4.der_encoder;
+	td->xer_decoder    = asn_DEF_Int4.xer_decoder;
+	td->xer_encoder    = asn_DEF_Int4.xer_encoder;
+	td->uper_decoder   = asn_DEF_Int4.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Int4.per_constraints;
+	td->elements       = asn_DEF_Int4.elements;
+	td->elements_count = asn_DEF_Int4.elements_count;
+	td->specifics      = asn_DEF_Int4.specifics;
+}
+
+void
+Int5_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Int5_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Int5_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Int5_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Int5_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Int5_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Int5] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Int5_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_Int5_constr_1 = {
+	{ APC_CONSTRAINED,	 0,  0,  5,  5 }	/* (5..5) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Int5 = {
+	"Int5",
+	"Int5",
+	Int5_free,
+	Int5_print,
+	Int5_constraint,
+	Int5_decode_ber,
+	Int5_encode_der,
+	Int5_decode_xer,
+	Int5_encode_xer,
+	Int5_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Int5_tags_1,
+	sizeof(asn_DEF_Int5_tags_1)
+		/sizeof(asn_DEF_Int5_tags_1[0]), /* 1 */
+	asn_DEF_Int5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Int5_tags_1)
+		/sizeof(asn_DEF_Int5_tags_1[0]), /* 1 */
+	&asn_PER_Int5_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [ExtensibleExtensions] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [ExtensibleExtensions] >>> ***/
+
+typedef INTEGER_t	 ExtensibleExtensions_t;
+
+/*** <<< FUNC-DECLS [ExtensibleExtensions] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_ExtensibleExtensions;
+asn_struct_free_f ExtensibleExtensions_free;
+asn_struct_print_f ExtensibleExtensions_print;
+asn_constr_check_f ExtensibleExtensions_constraint;
+ber_type_decoder_f ExtensibleExtensions_decode_ber;
+der_type_encoder_f ExtensibleExtensions_encode_der;
+xer_type_decoder_f ExtensibleExtensions_decode_xer;
+xer_type_encoder_f ExtensibleExtensions_encode_xer;
+per_type_decoder_f ExtensibleExtensions_decode_uper;
+
+/*** <<< CODE [ExtensibleExtensions] >>> ***/
+
+int
+ExtensibleExtensions_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 1 && value <= 256)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ExtensibleExtensions_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+ExtensibleExtensions_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ExtensibleExtensions_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	ExtensibleExtensions_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	ExtensibleExtensions_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+ExtensibleExtensions_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	ExtensibleExtensions_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [ExtensibleExtensions] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_ExtensibleExtensions_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_ExtensibleExtensions_constr_1 = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  8,  8,  1,  256 }	/* (1..256,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_ExtensibleExtensions = {
+	"ExtensibleExtensions",
+	"ExtensibleExtensions",
+	ExtensibleExtensions_free,
+	ExtensibleExtensions_print,
+	ExtensibleExtensions_constraint,
+	ExtensibleExtensions_decode_ber,
+	ExtensibleExtensions_encode_der,
+	ExtensibleExtensions_decode_xer,
+	ExtensibleExtensions_encode_xer,
+	ExtensibleExtensions_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ExtensibleExtensions_tags_1,
+	sizeof(asn_DEF_ExtensibleExtensions_tags_1)
+		/sizeof(asn_DEF_ExtensibleExtensions_tags_1[0]), /* 1 */
+	asn_DEF_ExtensibleExtensions_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ExtensibleExtensions_tags_1)
+		/sizeof(asn_DEF_ExtensibleExtensions_tags_1[0]), /* 1 */
+	&asn_PER_ExtensibleExtensions_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Str1] >>> ***/
+
+#include <IA5String.h>
+
+/*** <<< TYPE-DECLS [Str1] >>> ***/
+
+typedef IA5String_t	 Str1_t;
+
+/*** <<< FUNC-DECLS [Str1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Str1;
+asn_struct_free_f Str1_free;
+asn_struct_print_f Str1_print;
+asn_constr_check_f Str1_constraint;
+ber_type_decoder_f Str1_decode_ber;
+der_type_encoder_f Str1_encode_der;
+xer_type_decoder_f Str1_decode_xer;
+xer_type_encoder_f Str1_encode_xer;
+per_type_decoder_f Str1_decode_uper;
+
+/*** <<< CODE [Str1] >>> ***/
+
+int
+Str1_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_IA5String.check_constraints;
+	return td->check_constraints(td, sptr, app_errlog, app_key);
+}
+
+/*
+ * This type is implemented using IA5String,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Str1_1_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;
+	td->der_encoder    = asn_DEF_IA5String.der_encoder;
+	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
+	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
+	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_IA5String.per_constraints;
+	td->elements       = asn_DEF_IA5String.elements;
+	td->elements_count = asn_DEF_IA5String.elements_count;
+	td->specifics      = asn_DEF_IA5String.specifics;
+}
+
+void
+Str1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Str1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Str1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Str1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Str1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Str1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Str1_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) {
+	Str1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Str1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Str1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Str1_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) {
+	Str1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Str1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Str1_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Str1] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Str1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Str1 = {
+	"Str1",
+	"Str1",
+	Str1_free,
+	Str1_print,
+	Str1_constraint,
+	Str1_decode_ber,
+	Str1_encode_der,
+	Str1_decode_xer,
+	Str1_encode_xer,
+	Str1_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Str1_tags_1,
+	sizeof(asn_DEF_Str1_tags_1)
+		/sizeof(asn_DEF_Str1_tags_1[0]), /* 1 */
+	asn_DEF_Str1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Str1_tags_1)
+		/sizeof(asn_DEF_Str1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Str2] >>> ***/
+
+#include <Str1.h>
+
+/*** <<< TYPE-DECLS [Str2] >>> ***/
+
+typedef Str1_t	 Str2_t;
+
+/*** <<< FUNC-DECLS [Str2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Str2;
+asn_struct_free_f Str2_free;
+asn_struct_print_f Str2_print;
+asn_constr_check_f Str2_constraint;
+ber_type_decoder_f Str2_decode_ber;
+der_type_encoder_f Str2_encode_der;
+xer_type_decoder_f Str2_decode_xer;
+xer_type_encoder_f Str2_encode_xer;
+per_type_decoder_f Str2_decode_uper;
+
+/*** <<< CTABLES [Str2] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv <= 127)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Str2] >>> ***/
+
+int
+Str2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Str1_t *st = (const Str1_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if(((size <= 20) || (size >= 25 && size <= 30))
+		 && !check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Str1,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Str2_1_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;
+	td->der_encoder    = asn_DEF_Str1.der_encoder;
+	td->xer_decoder    = asn_DEF_Str1.xer_decoder;
+	td->xer_encoder    = asn_DEF_Str1.xer_encoder;
+	td->uper_decoder   = asn_DEF_Str1.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Str1.per_constraints;
+	td->elements       = asn_DEF_Str1.elements;
+	td->elements_count = asn_DEF_Str1.elements_count;
+	td->specifics      = asn_DEF_Str1.specifics;
+}
+
+void
+Str2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Str2_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Str2_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Str2_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Str2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Str2_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Str2] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Str2_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_Str2_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 5,  5,  0,  30 }	/* (SIZE(0..30)) */
+};
+asn_TYPE_descriptor_t asn_DEF_Str2 = {
+	"Str2",
+	"Str2",
+	Str2_free,
+	Str2_print,
+	Str2_constraint,
+	Str2_decode_ber,
+	Str2_encode_der,
+	Str2_decode_xer,
+	Str2_encode_xer,
+	Str2_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Str2_tags_1,
+	sizeof(asn_DEF_Str2_tags_1)
+		/sizeof(asn_DEF_Str2_tags_1[0]), /* 1 */
+	asn_DEF_Str2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Str2_tags_1)
+		/sizeof(asn_DEF_Str2_tags_1[0]), /* 1 */
+	&asn_PER_Str2_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Str3] >>> ***/
+
+#include <Str2.h>
+
+/*** <<< TYPE-DECLS [Str3] >>> ***/
+
+typedef Str2_t	 Str3_t;
+
+/*** <<< FUNC-DECLS [Str3] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Str3;
+asn_struct_free_f Str3_free;
+asn_struct_print_f Str3_print;
+asn_constr_check_f Str3_constraint;
+ber_type_decoder_f Str3_decode_ber;
+der_type_encoder_f Str3_encode_der;
+xer_type_decoder_f Str3_decode_xer;
+xer_type_encoder_f Str3_encode_xer;
+per_type_decoder_f Str3_decode_uper;
+
+/*** <<< CTABLES [Str3] >>> ***/
+
+static int permitted_alphabet_table_1[256] = {
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,	/*  ABC             */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,	/*     def          */
+};
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	int *table = permitted_alphabet_table_1;
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Str3] >>> ***/
+
+int
+Str3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Str2_t *st = (const Str2_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if(((size >= 10 && size <= 20) || (size >= 25 && size <= 27))
+		 && !check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Str2,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Str3_1_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;
+	td->der_encoder    = asn_DEF_Str2.der_encoder;
+	td->xer_decoder    = asn_DEF_Str2.xer_decoder;
+	td->xer_encoder    = asn_DEF_Str2.xer_encoder;
+	td->uper_decoder   = asn_DEF_Str2.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Str2.per_constraints;
+	td->elements       = asn_DEF_Str2.elements;
+	td->elements_count = asn_DEF_Str2.elements_count;
+	td->specifics      = asn_DEF_Str2.specifics;
+}
+
+void
+Str3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Str3_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Str3_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Str3_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Str3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Str3_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Str3] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Str3_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_Str3_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 5,  5,  10,  27 }	/* (SIZE(10..27)) */
+};
+asn_TYPE_descriptor_t asn_DEF_Str3 = {
+	"Str3",
+	"Str3",
+	Str3_free,
+	Str3_print,
+	Str3_constraint,
+	Str3_decode_ber,
+	Str3_encode_der,
+	Str3_decode_xer,
+	Str3_encode_xer,
+	Str3_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Str3_tags_1,
+	sizeof(asn_DEF_Str3_tags_1)
+		/sizeof(asn_DEF_Str3_tags_1[0]), /* 1 */
+	asn_DEF_Str3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Str3_tags_1)
+		/sizeof(asn_DEF_Str3_tags_1[0]), /* 1 */
+	&asn_PER_Str3_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Str4] >>> ***/
+
+#include <IA5String.h>
+
+/*** <<< TYPE-DECLS [Str4] >>> ***/
+
+typedef IA5String_t	 Str4_t;
+
+/*** <<< FUNC-DECLS [Str4] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Str4;
+asn_struct_free_f Str4_free;
+asn_struct_print_f Str4_print;
+asn_constr_check_f Str4_constraint;
+ber_type_decoder_f Str4_decode_ber;
+der_type_encoder_f Str4_encode_der;
+xer_type_decoder_f Str4_decode_xer;
+xer_type_encoder_f Str4_encode_xer;
+per_type_decoder_f Str4_decode_uper;
+
+/*** <<< CTABLES [Str4] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv <= 127)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Str4] >>> ***/
+
+int
+Str4_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;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(!check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using IA5String,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Str4_1_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;
+	td->der_encoder    = asn_DEF_IA5String.der_encoder;
+	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
+	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
+	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_IA5String.per_constraints;
+	td->elements       = asn_DEF_IA5String.elements;
+	td->elements_count = asn_DEF_IA5String.elements_count;
+	td->specifics      = asn_DEF_IA5String.specifics;
+}
+
+void
+Str4_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Str4_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Str4_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Str4_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Str4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Str4_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Str4] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Str4_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_Str4_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  0,  0 }	/* (SIZE(0..MAX)) */
+};
+asn_TYPE_descriptor_t asn_DEF_Str4 = {
+	"Str4",
+	"Str4",
+	Str4_free,
+	Str4_print,
+	Str4_constraint,
+	Str4_decode_ber,
+	Str4_encode_der,
+	Str4_decode_xer,
+	Str4_encode_xer,
+	Str4_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Str4_tags_1,
+	sizeof(asn_DEF_Str4_tags_1)
+		/sizeof(asn_DEF_Str4_tags_1[0]), /* 1 */
+	asn_DEF_Str4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Str4_tags_1)
+		/sizeof(asn_DEF_Str4_tags_1[0]), /* 1 */
+	&asn_PER_Str4_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [PER-Visible] >>> ***/
+
+#include <IA5String.h>
+
+/*** <<< TYPE-DECLS [PER-Visible] >>> ***/
+
+typedef IA5String_t	 PER_Visible_t;
+
+/*** <<< FUNC-DECLS [PER-Visible] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_PER_Visible;
+asn_struct_free_f PER_Visible_free;
+asn_struct_print_f PER_Visible_print;
+asn_constr_check_f PER_Visible_constraint;
+ber_type_decoder_f PER_Visible_decode_ber;
+der_type_encoder_f PER_Visible_encode_der;
+xer_type_decoder_f PER_Visible_decode_xer;
+xer_type_encoder_f PER_Visible_encode_xer;
+per_type_decoder_f PER_Visible_decode_uper;
+
+/*** <<< CTABLES [PER-Visible] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 65 && cv <= 70)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [PER-Visible] >>> ***/
+
+int
+PER_Visible_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;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(!check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using IA5String,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+PER_Visible_1_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;
+	td->der_encoder    = asn_DEF_IA5String.der_encoder;
+	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
+	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
+	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_IA5String.per_constraints;
+	td->elements       = asn_DEF_IA5String.elements;
+	td->elements_count = asn_DEF_IA5String.elements_count;
+	td->specifics      = asn_DEF_IA5String.specifics;
+}
+
+void
+PER_Visible_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	PER_Visible_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	PER_Visible_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	PER_Visible_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+PER_Visible_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	PER_Visible_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [PER-Visible] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_PER_Visible_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_PER_Visible_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  0,  0 }	/* (SIZE(0..MAX)) */
+};
+asn_TYPE_descriptor_t asn_DEF_PER_Visible = {
+	"PER-Visible",
+	"PER-Visible",
+	PER_Visible_free,
+	PER_Visible_print,
+	PER_Visible_constraint,
+	PER_Visible_decode_ber,
+	PER_Visible_encode_der,
+	PER_Visible_decode_xer,
+	PER_Visible_encode_xer,
+	PER_Visible_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_PER_Visible_tags_1,
+	sizeof(asn_DEF_PER_Visible_tags_1)
+		/sizeof(asn_DEF_PER_Visible_tags_1[0]), /* 1 */
+	asn_DEF_PER_Visible_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PER_Visible_tags_1)
+		/sizeof(asn_DEF_PER_Visible_tags_1[0]), /* 1 */
+	&asn_PER_PER_Visible_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [PER-Visible-2] >>> ***/
+
+#include <PER-Visible.h>
+
+/*** <<< TYPE-DECLS [PER-Visible-2] >>> ***/
+
+typedef PER_Visible_t	 PER_Visible_2_t;
+
+/*** <<< FUNC-DECLS [PER-Visible-2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_PER_Visible_2;
+asn_struct_free_f PER_Visible_2_free;
+asn_struct_print_f PER_Visible_2_print;
+asn_constr_check_f PER_Visible_2_constraint;
+ber_type_decoder_f PER_Visible_2_decode_ber;
+der_type_encoder_f PER_Visible_2_encode_der;
+xer_type_decoder_f PER_Visible_2_decode_xer;
+xer_type_encoder_f PER_Visible_2_encode_xer;
+per_type_decoder_f PER_Visible_2_decode_uper;
+
+/*** <<< CTABLES [PER-Visible-2] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 69 && cv <= 70)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [PER-Visible-2] >>> ***/
+
+int
+PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const PER_Visible_t *st = (const PER_Visible_t *)sptr;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(!check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using PER_Visible,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+PER_Visible_2_1_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;
+	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
+	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
+	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
+	td->elements       = asn_DEF_PER_Visible.elements;
+	td->elements_count = asn_DEF_PER_Visible.elements_count;
+	td->specifics      = asn_DEF_PER_Visible.specifics;
+}
+
+void
+PER_Visible_2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	PER_Visible_2_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	PER_Visible_2_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	PER_Visible_2_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+PER_Visible_2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	PER_Visible_2_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [PER-Visible-2] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_PER_Visible_2_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_PER_Visible_2_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  0,  0 }	/* (SIZE(0..MAX)) */
+};
+asn_TYPE_descriptor_t asn_DEF_PER_Visible_2 = {
+	"PER-Visible-2",
+	"PER-Visible-2",
+	PER_Visible_2_free,
+	PER_Visible_2_print,
+	PER_Visible_2_constraint,
+	PER_Visible_2_decode_ber,
+	PER_Visible_2_encode_der,
+	PER_Visible_2_decode_xer,
+	PER_Visible_2_encode_xer,
+	PER_Visible_2_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_PER_Visible_2_tags_1,
+	sizeof(asn_DEF_PER_Visible_2_tags_1)
+		/sizeof(asn_DEF_PER_Visible_2_tags_1[0]), /* 1 */
+	asn_DEF_PER_Visible_2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PER_Visible_2_tags_1)
+		/sizeof(asn_DEF_PER_Visible_2_tags_1[0]), /* 1 */
+	&asn_PER_PER_Visible_2_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Not-PER-Visible-1] >>> ***/
+
+#include <PER-Visible.h>
+
+/*** <<< TYPE-DECLS [Not-PER-Visible-1] >>> ***/
+
+typedef PER_Visible_t	 Not_PER_Visible_1_t;
+
+/*** <<< FUNC-DECLS [Not-PER-Visible-1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_1;
+asn_struct_free_f Not_PER_Visible_1_free;
+asn_struct_print_f Not_PER_Visible_1_print;
+asn_constr_check_f Not_PER_Visible_1_constraint;
+ber_type_decoder_f Not_PER_Visible_1_decode_ber;
+der_type_encoder_f Not_PER_Visible_1_encode_der;
+xer_type_decoder_f Not_PER_Visible_1_decode_xer;
+xer_type_encoder_f Not_PER_Visible_1_encode_xer;
+per_type_decoder_f Not_PER_Visible_1_decode_uper;
+
+/*** <<< CTABLES [Not-PER-Visible-1] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 65 && cv <= 70)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Not-PER-Visible-1] >>> ***/
+
+int
+Not_PER_Visible_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const PER_Visible_t *st = (const PER_Visible_t *)sptr;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(!check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using PER_Visible,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Not_PER_Visible_1_1_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;
+	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
+	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
+	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
+	td->elements       = asn_DEF_PER_Visible.elements;
+	td->elements_count = asn_DEF_PER_Visible.elements_count;
+	td->specifics      = asn_DEF_PER_Visible.specifics;
+}
+
+void
+Not_PER_Visible_1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Not_PER_Visible_1_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Not_PER_Visible_1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Not_PER_Visible_1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Not_PER_Visible_1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Not_PER_Visible_1_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Not-PER-Visible-1] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_Not_PER_Visible_1_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  0,  0 }	/* (SIZE(0..MAX)) */
+};
+asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_1 = {
+	"Not-PER-Visible-1",
+	"Not-PER-Visible-1",
+	Not_PER_Visible_1_free,
+	Not_PER_Visible_1_print,
+	Not_PER_Visible_1_constraint,
+	Not_PER_Visible_1_decode_ber,
+	Not_PER_Visible_1_encode_der,
+	Not_PER_Visible_1_decode_xer,
+	Not_PER_Visible_1_encode_xer,
+	Not_PER_Visible_1_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Not_PER_Visible_1_tags_1,
+	sizeof(asn_DEF_Not_PER_Visible_1_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_1_tags_1[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_1_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_1_tags_1[0]), /* 1 */
+	&asn_PER_Not_PER_Visible_1_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Not-PER-Visible-2] >>> ***/
+
+#include <PER-Visible.h>
+
+/*** <<< TYPE-DECLS [Not-PER-Visible-2] >>> ***/
+
+typedef PER_Visible_t	 Not_PER_Visible_2_t;
+
+/*** <<< FUNC-DECLS [Not-PER-Visible-2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_2;
+asn_struct_free_f Not_PER_Visible_2_free;
+asn_struct_print_f Not_PER_Visible_2_print;
+asn_constr_check_f Not_PER_Visible_2_constraint;
+ber_type_decoder_f Not_PER_Visible_2_decode_ber;
+der_type_encoder_f Not_PER_Visible_2_encode_der;
+xer_type_decoder_f Not_PER_Visible_2_decode_xer;
+xer_type_encoder_f Not_PER_Visible_2_encode_xer;
+per_type_decoder_f Not_PER_Visible_2_decode_uper;
+
+/*** <<< CTABLES [Not-PER-Visible-2] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 65 && cv <= 66)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Not-PER-Visible-2] >>> ***/
+
+int
+Not_PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const PER_Visible_t *st = (const PER_Visible_t *)sptr;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(!check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using PER_Visible,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Not_PER_Visible_2_1_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;
+	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
+	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
+	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
+	td->elements       = asn_DEF_PER_Visible.elements;
+	td->elements_count = asn_DEF_PER_Visible.elements_count;
+	td->specifics      = asn_DEF_PER_Visible.specifics;
+}
+
+void
+Not_PER_Visible_2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Not_PER_Visible_2_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Not_PER_Visible_2_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Not_PER_Visible_2_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Not_PER_Visible_2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Not_PER_Visible_2_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Not-PER-Visible-2] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_2_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_Not_PER_Visible_2_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  0,  0 }	/* (SIZE(0..MAX)) */
+};
+asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_2 = {
+	"Not-PER-Visible-2",
+	"Not-PER-Visible-2",
+	Not_PER_Visible_2_free,
+	Not_PER_Visible_2_print,
+	Not_PER_Visible_2_constraint,
+	Not_PER_Visible_2_decode_ber,
+	Not_PER_Visible_2_encode_der,
+	Not_PER_Visible_2_decode_xer,
+	Not_PER_Visible_2_encode_xer,
+	Not_PER_Visible_2_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Not_PER_Visible_2_tags_1,
+	sizeof(asn_DEF_Not_PER_Visible_2_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_2_tags_1[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_2_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_2_tags_1[0]), /* 1 */
+	&asn_PER_Not_PER_Visible_2_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Not-PER-Visible-3] >>> ***/
+
+#include <PER-Visible.h>
+
+/*** <<< TYPE-DECLS [Not-PER-Visible-3] >>> ***/
+
+typedef PER_Visible_t	 Not_PER_Visible_3_t;
+
+/*** <<< FUNC-DECLS [Not-PER-Visible-3] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_3;
+asn_struct_free_f Not_PER_Visible_3_free;
+asn_struct_print_f Not_PER_Visible_3_print;
+asn_constr_check_f Not_PER_Visible_3_constraint;
+ber_type_decoder_f Not_PER_Visible_3_decode_ber;
+der_type_encoder_f Not_PER_Visible_3_encode_der;
+xer_type_decoder_f Not_PER_Visible_3_decode_xer;
+xer_type_encoder_f Not_PER_Visible_3_encode_xer;
+per_type_decoder_f Not_PER_Visible_3_decode_uper;
+
+/*** <<< CTABLES [Not-PER-Visible-3] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 65 && cv <= 66)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Not-PER-Visible-3] >>> ***/
+
+int
+Not_PER_Visible_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const PER_Visible_t *st = (const PER_Visible_t *)sptr;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(!check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using PER_Visible,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Not_PER_Visible_3_1_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;
+	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
+	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
+	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
+	td->elements       = asn_DEF_PER_Visible.elements;
+	td->elements_count = asn_DEF_PER_Visible.elements_count;
+	td->specifics      = asn_DEF_PER_Visible.specifics;
+}
+
+void
+Not_PER_Visible_3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Not_PER_Visible_3_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Not_PER_Visible_3_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Not_PER_Visible_3_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Not_PER_Visible_3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Not_PER_Visible_3_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Not-PER-Visible-3] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Not_PER_Visible_3_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_Not_PER_Visible_3_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  0,  0 }	/* (SIZE(0..MAX)) */
+};
+asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_3 = {
+	"Not-PER-Visible-3",
+	"Not-PER-Visible-3",
+	Not_PER_Visible_3_free,
+	Not_PER_Visible_3_print,
+	Not_PER_Visible_3_constraint,
+	Not_PER_Visible_3_decode_ber,
+	Not_PER_Visible_3_encode_der,
+	Not_PER_Visible_3_decode_xer,
+	Not_PER_Visible_3_encode_xer,
+	Not_PER_Visible_3_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Not_PER_Visible_3_tags_1,
+	sizeof(asn_DEF_Not_PER_Visible_3_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_3_tags_1[0]), /* 1 */
+	asn_DEF_Not_PER_Visible_3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Not_PER_Visible_3_tags_1)
+		/sizeof(asn_DEF_Not_PER_Visible_3_tags_1[0]), /* 1 */
+	&asn_PER_Not_PER_Visible_3_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [SIZE-but-not-FROM] >>> ***/
+
+#include <PER-Visible.h>
+
+/*** <<< TYPE-DECLS [SIZE-but-not-FROM] >>> ***/
+
+typedef PER_Visible_t	 SIZE_but_not_FROM_t;
+
+/*** <<< FUNC-DECLS [SIZE-but-not-FROM] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_SIZE_but_not_FROM;
+asn_struct_free_f SIZE_but_not_FROM_free;
+asn_struct_print_f SIZE_but_not_FROM_print;
+asn_constr_check_f SIZE_but_not_FROM_constraint;
+ber_type_decoder_f SIZE_but_not_FROM_decode_ber;
+der_type_encoder_f SIZE_but_not_FROM_encode_der;
+xer_type_decoder_f SIZE_but_not_FROM_decode_xer;
+xer_type_encoder_f SIZE_but_not_FROM_encode_xer;
+per_type_decoder_f SIZE_but_not_FROM_decode_uper;
+
+/*** <<< CTABLES [SIZE-but-not-FROM] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 65 && cv <= 68)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [SIZE-but-not-FROM] >>> ***/
+
+int
+SIZE_but_not_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const PER_Visible_t *st = (const PER_Visible_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 4)
+		 && !check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using PER_Visible,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SIZE_but_not_FROM_1_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;
+	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
+	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
+	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
+	td->elements       = asn_DEF_PER_Visible.elements;
+	td->elements_count = asn_DEF_PER_Visible.elements_count;
+	td->specifics      = asn_DEF_PER_Visible.specifics;
+}
+
+void
+SIZE_but_not_FROM_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SIZE_but_not_FROM_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	SIZE_but_not_FROM_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	SIZE_but_not_FROM_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SIZE_but_not_FROM_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SIZE_but_not_FROM_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [SIZE-but-not-FROM] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_SIZE_but_not_FROM_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_SIZE_but_not_FROM_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 2,  2,  1,  4 }	/* (SIZE(1..4)) */
+};
+asn_TYPE_descriptor_t asn_DEF_SIZE_but_not_FROM = {
+	"SIZE-but-not-FROM",
+	"SIZE-but-not-FROM",
+	SIZE_but_not_FROM_free,
+	SIZE_but_not_FROM_print,
+	SIZE_but_not_FROM_constraint,
+	SIZE_but_not_FROM_decode_ber,
+	SIZE_but_not_FROM_encode_der,
+	SIZE_but_not_FROM_decode_xer,
+	SIZE_but_not_FROM_encode_xer,
+	SIZE_but_not_FROM_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SIZE_but_not_FROM_tags_1,
+	sizeof(asn_DEF_SIZE_but_not_FROM_tags_1)
+		/sizeof(asn_DEF_SIZE_but_not_FROM_tags_1[0]), /* 1 */
+	asn_DEF_SIZE_but_not_FROM_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SIZE_but_not_FROM_tags_1)
+		/sizeof(asn_DEF_SIZE_but_not_FROM_tags_1[0]), /* 1 */
+	&asn_PER_SIZE_but_not_FROM_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [SIZE-and-FROM] >>> ***/
+
+#include <PER-Visible.h>
+
+/*** <<< TYPE-DECLS [SIZE-and-FROM] >>> ***/
+
+typedef PER_Visible_t	 SIZE_and_FROM_t;
+
+/*** <<< FUNC-DECLS [SIZE-and-FROM] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_SIZE_and_FROM;
+asn_struct_free_f SIZE_and_FROM_free;
+asn_struct_print_f SIZE_and_FROM_print;
+asn_constr_check_f SIZE_and_FROM_constraint;
+ber_type_decoder_f SIZE_and_FROM_decode_ber;
+der_type_encoder_f SIZE_and_FROM_encode_der;
+xer_type_decoder_f SIZE_and_FROM_decode_xer;
+xer_type_encoder_f SIZE_and_FROM_encode_xer;
+per_type_decoder_f SIZE_and_FROM_decode_uper;
+
+/*** <<< CTABLES [SIZE-and-FROM] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 65 && cv <= 68)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [SIZE-and-FROM] >>> ***/
+
+int
+SIZE_and_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const PER_Visible_t *st = (const PER_Visible_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 4)
+		 && !check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using PER_Visible,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SIZE_and_FROM_1_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;
+	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
+	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
+	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
+	td->elements       = asn_DEF_PER_Visible.elements;
+	td->elements_count = asn_DEF_PER_Visible.elements_count;
+	td->specifics      = asn_DEF_PER_Visible.specifics;
+}
+
+void
+SIZE_and_FROM_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SIZE_and_FROM_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	SIZE_and_FROM_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	SIZE_and_FROM_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SIZE_and_FROM_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SIZE_and_FROM_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [SIZE-and-FROM] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_SIZE_and_FROM_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_SIZE_and_FROM_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 2,  2,  1,  4 }	/* (SIZE(1..4)) */
+};
+asn_TYPE_descriptor_t asn_DEF_SIZE_and_FROM = {
+	"SIZE-and-FROM",
+	"SIZE-and-FROM",
+	SIZE_and_FROM_free,
+	SIZE_and_FROM_print,
+	SIZE_and_FROM_constraint,
+	SIZE_and_FROM_decode_ber,
+	SIZE_and_FROM_encode_der,
+	SIZE_and_FROM_decode_xer,
+	SIZE_and_FROM_encode_xer,
+	SIZE_and_FROM_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SIZE_and_FROM_tags_1,
+	sizeof(asn_DEF_SIZE_and_FROM_tags_1)
+		/sizeof(asn_DEF_SIZE_and_FROM_tags_1[0]), /* 1 */
+	asn_DEF_SIZE_and_FROM_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SIZE_and_FROM_tags_1)
+		/sizeof(asn_DEF_SIZE_and_FROM_tags_1[0]), /* 1 */
+	&asn_PER_SIZE_and_FROM_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Neither-SIZE-nor-FROM] >>> ***/
+
+#include <PER-Visible.h>
+
+/*** <<< TYPE-DECLS [Neither-SIZE-nor-FROM] >>> ***/
+
+typedef PER_Visible_t	 Neither_SIZE_nor_FROM_t;
+
+/*** <<< FUNC-DECLS [Neither-SIZE-nor-FROM] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Neither_SIZE_nor_FROM;
+asn_struct_free_f Neither_SIZE_nor_FROM_free;
+asn_struct_print_f Neither_SIZE_nor_FROM_print;
+asn_constr_check_f Neither_SIZE_nor_FROM_constraint;
+ber_type_decoder_f Neither_SIZE_nor_FROM_decode_ber;
+der_type_encoder_f Neither_SIZE_nor_FROM_encode_der;
+xer_type_decoder_f Neither_SIZE_nor_FROM_decode_xer;
+xer_type_encoder_f Neither_SIZE_nor_FROM_encode_xer;
+per_type_decoder_f Neither_SIZE_nor_FROM_decode_uper;
+
+/*** <<< CTABLES [Neither-SIZE-nor-FROM] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 65 && cv <= 70)) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Neither-SIZE-nor-FROM] >>> ***/
+
+int
+Neither_SIZE_nor_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const PER_Visible_t *st = (const PER_Visible_t *)sptr;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(!check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using PER_Visible,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Neither_SIZE_nor_FROM_1_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;
+	td->der_encoder    = asn_DEF_PER_Visible.der_encoder;
+	td->xer_decoder    = asn_DEF_PER_Visible.xer_decoder;
+	td->xer_encoder    = asn_DEF_PER_Visible.xer_encoder;
+	td->uper_decoder   = asn_DEF_PER_Visible.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
+	td->elements       = asn_DEF_PER_Visible.elements;
+	td->elements_count = asn_DEF_PER_Visible.elements_count;
+	td->specifics      = asn_DEF_PER_Visible.specifics;
+}
+
+void
+Neither_SIZE_nor_FROM_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Neither_SIZE_nor_FROM_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Neither_SIZE_nor_FROM_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Neither_SIZE_nor_FROM_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Neither_SIZE_nor_FROM_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Neither_SIZE_nor_FROM_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Neither-SIZE-nor-FROM] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Neither_SIZE_nor_FROM_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+static asn_per_constraints_t asn_PER_Neither_SIZE_nor_FROM_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  0,  0 }	/* (SIZE(0..MAX)) */
+};
+asn_TYPE_descriptor_t asn_DEF_Neither_SIZE_nor_FROM = {
+	"Neither-SIZE-nor-FROM",
+	"Neither-SIZE-nor-FROM",
+	Neither_SIZE_nor_FROM_free,
+	Neither_SIZE_nor_FROM_print,
+	Neither_SIZE_nor_FROM_constraint,
+	Neither_SIZE_nor_FROM_decode_ber,
+	Neither_SIZE_nor_FROM_encode_der,
+	Neither_SIZE_nor_FROM_decode_xer,
+	Neither_SIZE_nor_FROM_encode_xer,
+	Neither_SIZE_nor_FROM_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Neither_SIZE_nor_FROM_tags_1,
+	sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1)
+		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1[0]), /* 1 */
+	asn_DEF_Neither_SIZE_nor_FROM_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1)
+		/sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1[0]), /* 1 */
+	&asn_PER_Neither_SIZE_nor_FROM_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Utf8-4] >>> ***/
+
+#include <UTF8String.h>
+
+/*** <<< TYPE-DECLS [Utf8-4] >>> ***/
+
+typedef UTF8String_t	 Utf8_4_t;
+
+/*** <<< FUNC-DECLS [Utf8-4] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Utf8_4;
+asn_struct_free_f Utf8_4_free;
+asn_struct_print_f Utf8_4_print;
+asn_constr_check_f Utf8_4_constraint;
+ber_type_decoder_f Utf8_4_decode_ber;
+der_type_encoder_f Utf8_4_encode_der;
+xer_type_decoder_f Utf8_4_decode_xer;
+xer_type_encoder_f Utf8_4_encode_xer;
+per_type_decoder_f Utf8_4_decode_uper;
+
+/*** <<< CTABLES [Utf8-4] >>> ***/
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	if(UTF8String_length((const UTF8String_t *)sptr) < 0)
+		return -1; /* Alphabet (sic!) test failed. */
+	
+	return 0;
+}
+
+
+/*** <<< CODE [Utf8-4] >>> ***/
+
+int
+Utf8_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const UTF8String_t *st = (const UTF8String_t *)sptr;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(!check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using UTF8String,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Utf8_4_1_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;
+	td->der_encoder    = asn_DEF_UTF8String.der_encoder;
+	td->xer_decoder    = asn_DEF_UTF8String.xer_decoder;
+	td->xer_encoder    = asn_DEF_UTF8String.xer_encoder;
+	td->uper_decoder   = asn_DEF_UTF8String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_UTF8String.per_constraints;
+	td->elements       = asn_DEF_UTF8String.elements;
+	td->elements_count = asn_DEF_UTF8String.elements_count;
+	td->specifics      = asn_DEF_UTF8String.specifics;
+}
+
+void
+Utf8_4_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Utf8_4_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Utf8_4_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Utf8_4_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Utf8_4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Utf8_4_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Utf8-4] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Utf8_4_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
+};
+static asn_per_constraints_t asn_PER_Utf8_4_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Utf8_4 = {
+	"Utf8-4",
+	"Utf8-4",
+	Utf8_4_free,
+	Utf8_4_print,
+	Utf8_4_constraint,
+	Utf8_4_decode_ber,
+	Utf8_4_encode_der,
+	Utf8_4_decode_xer,
+	Utf8_4_encode_xer,
+	Utf8_4_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Utf8_4_tags_1,
+	sizeof(asn_DEF_Utf8_4_tags_1)
+		/sizeof(asn_DEF_Utf8_4_tags_1[0]), /* 1 */
+	asn_DEF_Utf8_4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Utf8_4_tags_1)
+		/sizeof(asn_DEF_Utf8_4_tags_1[0]), /* 1 */
+	&asn_PER_Utf8_4_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Utf8-3] >>> ***/
+
+#include <Utf8-2.h>
+
+/*** <<< TYPE-DECLS [Utf8-3] >>> ***/
+
+typedef Utf8_2_t	 Utf8_3_t;
+
+/*** <<< FUNC-DECLS [Utf8-3] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Utf8_3;
+asn_struct_free_f Utf8_3_free;
+asn_struct_print_f Utf8_3_print;
+asn_constr_check_f Utf8_3_constraint;
+ber_type_decoder_f Utf8_3_decode_ber;
+der_type_encoder_f Utf8_3_encode_der;
+xer_type_decoder_f Utf8_3_decode_xer;
+xer_type_encoder_f Utf8_3_encode_xer;
+per_type_decoder_f Utf8_3_decode_uper;
+
+/*** <<< CTABLES [Utf8-3] >>> ***/
+
+static int permitted_alphabet_table_1[128] = {
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,	/*  ABCDEFGHIJKLMNO */
+1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,	/* PQRSTUVWXYZ      */
+0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,	/*  abcdefghijklmno */
+1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,	/* pqrstuvwxyz      */
+};
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	int *table = permitted_alphabet_table_1;
+	/* The underlying type is UTF8String */
+	const UTF8String_t *st = (const UTF8String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(cv >= 0x80) return -1;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Utf8-3] >>> ***/
+
+int
+Utf8_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Utf8_2_t *st = (const Utf8_2_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = UTF8String_length(st);
+	if((ssize_t)size < 0) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: UTF-8: broken encoding (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((size >= 1 && size <= 2)
+		 && !check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Utf8_2,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Utf8_3_1_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;
+	td->der_encoder    = asn_DEF_Utf8_2.der_encoder;
+	td->xer_decoder    = asn_DEF_Utf8_2.xer_decoder;
+	td->xer_encoder    = asn_DEF_Utf8_2.xer_encoder;
+	td->uper_decoder   = asn_DEF_Utf8_2.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Utf8_2.per_constraints;
+	td->elements       = asn_DEF_Utf8_2.elements;
+	td->elements_count = asn_DEF_Utf8_2.elements_count;
+	td->specifics      = asn_DEF_Utf8_2.specifics;
+}
+
+void
+Utf8_3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Utf8_3_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Utf8_3_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Utf8_3_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Utf8_3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Utf8_3_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Utf8-3] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Utf8_3_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
+};
+static asn_per_constraints_t asn_PER_Utf8_3_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Utf8_3 = {
+	"Utf8-3",
+	"Utf8-3",
+	Utf8_3_free,
+	Utf8_3_print,
+	Utf8_3_constraint,
+	Utf8_3_decode_ber,
+	Utf8_3_encode_der,
+	Utf8_3_decode_xer,
+	Utf8_3_encode_xer,
+	Utf8_3_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Utf8_3_tags_1,
+	sizeof(asn_DEF_Utf8_3_tags_1)
+		/sizeof(asn_DEF_Utf8_3_tags_1[0]), /* 1 */
+	asn_DEF_Utf8_3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Utf8_3_tags_1)
+		/sizeof(asn_DEF_Utf8_3_tags_1[0]), /* 1 */
+	&asn_PER_Utf8_3_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Utf8-2] >>> ***/
+
+#include <Utf8-1.h>
+
+/*** <<< TYPE-DECLS [Utf8-2] >>> ***/
+
+typedef Utf8_1_t	 Utf8_2_t;
+
+/*** <<< FUNC-DECLS [Utf8-2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Utf8_2;
+asn_struct_free_f Utf8_2_free;
+asn_struct_print_f Utf8_2_print;
+asn_constr_check_f Utf8_2_constraint;
+ber_type_decoder_f Utf8_2_decode_ber;
+der_type_encoder_f Utf8_2_encode_der;
+xer_type_decoder_f Utf8_2_decode_xer;
+xer_type_encoder_f Utf8_2_encode_xer;
+per_type_decoder_f Utf8_2_decode_uper;
+
+/*** <<< CODE [Utf8-2] >>> ***/
+
+int
+Utf8_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Utf8_1_t *st = (const Utf8_1_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = UTF8String_length(st);
+	if((ssize_t)size < 0) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: UTF-8: broken encoding (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((size >= 1 && size <= 2)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Utf8_1,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Utf8_2_1_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;
+	td->der_encoder    = asn_DEF_Utf8_1.der_encoder;
+	td->xer_decoder    = asn_DEF_Utf8_1.xer_decoder;
+	td->xer_encoder    = asn_DEF_Utf8_1.xer_encoder;
+	td->uper_decoder   = asn_DEF_Utf8_1.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Utf8_1.per_constraints;
+	td->elements       = asn_DEF_Utf8_1.elements;
+	td->elements_count = asn_DEF_Utf8_1.elements_count;
+	td->specifics      = asn_DEF_Utf8_1.specifics;
+}
+
+void
+Utf8_2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Utf8_2_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Utf8_2_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Utf8_2_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Utf8_2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Utf8_2_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Utf8-2] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Utf8_2_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
+};
+static asn_per_constraints_t asn_PER_Utf8_2_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Utf8_2 = {
+	"Utf8-2",
+	"Utf8-2",
+	Utf8_2_free,
+	Utf8_2_print,
+	Utf8_2_constraint,
+	Utf8_2_decode_ber,
+	Utf8_2_encode_der,
+	Utf8_2_decode_xer,
+	Utf8_2_encode_xer,
+	Utf8_2_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Utf8_2_tags_1,
+	sizeof(asn_DEF_Utf8_2_tags_1)
+		/sizeof(asn_DEF_Utf8_2_tags_1[0]), /* 1 */
+	asn_DEF_Utf8_2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Utf8_2_tags_1)
+		/sizeof(asn_DEF_Utf8_2_tags_1[0]), /* 1 */
+	&asn_PER_Utf8_2_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Utf8-1] >>> ***/
+
+#include <UTF8String.h>
+
+/*** <<< TYPE-DECLS [Utf8-1] >>> ***/
+
+typedef UTF8String_t	 Utf8_1_t;
+
+/*** <<< FUNC-DECLS [Utf8-1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Utf8_1;
+asn_struct_free_f Utf8_1_free;
+asn_struct_print_f Utf8_1_print;
+asn_constr_check_f Utf8_1_constraint;
+ber_type_decoder_f Utf8_1_decode_ber;
+der_type_encoder_f Utf8_1_encode_der;
+xer_type_decoder_f Utf8_1_decode_xer;
+xer_type_encoder_f Utf8_1_encode_xer;
+per_type_decoder_f Utf8_1_decode_uper;
+
+/*** <<< CODE [Utf8-1] >>> ***/
+
+int
+Utf8_1_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_UTF8String.check_constraints;
+	return td->check_constraints(td, sptr, app_errlog, app_key);
+}
+
+/*
+ * This type is implemented using UTF8String,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Utf8_1_1_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;
+	td->der_encoder    = asn_DEF_UTF8String.der_encoder;
+	td->xer_decoder    = asn_DEF_UTF8String.xer_decoder;
+	td->xer_encoder    = asn_DEF_UTF8String.xer_encoder;
+	td->uper_decoder   = asn_DEF_UTF8String.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_UTF8String.per_constraints;
+	td->elements       = asn_DEF_UTF8String.elements;
+	td->elements_count = asn_DEF_UTF8String.elements_count;
+	td->specifics      = asn_DEF_UTF8String.specifics;
+}
+
+void
+Utf8_1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Utf8_1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Utf8_1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Utf8_1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Utf8_1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Utf8_1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Utf8_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) {
+	Utf8_1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Utf8_1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Utf8_1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Utf8_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) {
+	Utf8_1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Utf8_1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Utf8_1_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Utf8-1] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Utf8_1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (12 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Utf8_1 = {
+	"Utf8-1",
+	"Utf8-1",
+	Utf8_1_free,
+	Utf8_1_print,
+	Utf8_1_constraint,
+	Utf8_1_decode_ber,
+	Utf8_1_encode_der,
+	Utf8_1_decode_xer,
+	Utf8_1_encode_xer,
+	Utf8_1_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Utf8_1_tags_1,
+	sizeof(asn_DEF_Utf8_1_tags_1)
+		/sizeof(asn_DEF_Utf8_1_tags_1[0]), /* 1 */
+	asn_DEF_Utf8_1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Utf8_1_tags_1)
+		/sizeof(asn_DEF_Utf8_1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [VisibleIdentifier] >>> ***/
+
+#include <Identifier.h>
+
+/*** <<< TYPE-DECLS [VisibleIdentifier] >>> ***/
+
+typedef Identifier_t	 VisibleIdentifier_t;
+
+/*** <<< FUNC-DECLS [VisibleIdentifier] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_VisibleIdentifier;
+asn_struct_free_f VisibleIdentifier_free;
+asn_struct_print_f VisibleIdentifier_print;
+asn_constr_check_f VisibleIdentifier_constraint;
+ber_type_decoder_f VisibleIdentifier_decode_ber;
+der_type_encoder_f VisibleIdentifier_encode_der;
+xer_type_decoder_f VisibleIdentifier_decode_xer;
+xer_type_encoder_f VisibleIdentifier_encode_xer;
+per_type_decoder_f VisibleIdentifier_decode_uper;
+
+/*** <<< CTABLES [VisibleIdentifier] >>> ***/
+
+static int permitted_alphabet_table_1[256] = {
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,	/*     $            */
+1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,	/* 0123456789       */
+0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,	/*  ABCDEFGHIJKLMNO */
+1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,	/* PQRSTUVWXYZ    _ */
+0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,	/*  abcdefghijklmno */
+1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,	/* pqrstuvwxyz      */
+};
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	int *table = permitted_alphabet_table_1;
+	/* The underlying type is VisibleString */
+	const VisibleString_t *st = (const VisibleString_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [VisibleIdentifier] >>> ***/
+
+int
+VisibleIdentifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Identifier_t *st = (const Identifier_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 32)
+		 && !check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Identifier,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+VisibleIdentifier_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_Identifier.free_struct;
+	td->print_struct   = asn_DEF_Identifier.print_struct;
+	td->ber_decoder    = asn_DEF_Identifier.ber_decoder;
+	td->der_encoder    = asn_DEF_Identifier.der_encoder;
+	td->xer_decoder    = asn_DEF_Identifier.xer_decoder;
+	td->xer_encoder    = asn_DEF_Identifier.xer_encoder;
+	td->uper_decoder   = asn_DEF_Identifier.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Identifier.per_constraints;
+	td->elements       = asn_DEF_Identifier.elements;
+	td->elements_count = asn_DEF_Identifier.elements_count;
+	td->specifics      = asn_DEF_Identifier.specifics;
+}
+
+void
+VisibleIdentifier_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	VisibleIdentifier_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+VisibleIdentifier_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	VisibleIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+VisibleIdentifier_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	VisibleIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+VisibleIdentifier_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) {
+	VisibleIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+VisibleIdentifier_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	VisibleIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+VisibleIdentifier_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) {
+	VisibleIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+VisibleIdentifier_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	VisibleIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [VisibleIdentifier] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_VisibleIdentifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (26 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_VisibleIdentifier = {
+	"VisibleIdentifier",
+	"VisibleIdentifier",
+	VisibleIdentifier_free,
+	VisibleIdentifier_print,
+	VisibleIdentifier_constraint,
+	VisibleIdentifier_decode_ber,
+	VisibleIdentifier_encode_der,
+	VisibleIdentifier_decode_xer,
+	VisibleIdentifier_encode_xer,
+	VisibleIdentifier_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_VisibleIdentifier_tags_1,
+	sizeof(asn_DEF_VisibleIdentifier_tags_1)
+		/sizeof(asn_DEF_VisibleIdentifier_tags_1[0]), /* 1 */
+	asn_DEF_VisibleIdentifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_VisibleIdentifier_tags_1)
+		/sizeof(asn_DEF_VisibleIdentifier_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [Sequence] >>> ***/
+
+#include <Int1.h>
+#include <Int4.h>
+#include <BOOLEAN.h>
+#include <ENUMERATED.h>
+#include <NULL.h>
+#include <Int5.h>
+#include <constr_SEQUENCE.h>
+
+/*** <<< DEPS [Sequence] >>> ***/
+
+typedef enum enum_c {
+	enum_c_one	= 1,
+	enum_c_two	= 2,
+	/*
+	 * Enumeration is extensible
+	 */
+	enum_c_three	= 3
+} enum_c_e;
+
+/*** <<< TYPE-DECLS [Sequence] >>> ***/
+
+typedef struct Sequence {
+	Int1_t	*int1_c	/* DEFAULT 3 */;
+	Int4_t	 int4;
+	Int4_t	 int4_c;
+	BOOLEAN_t	*bool	/* DEFAULT 1 */;
+	ENUMERATED_t	 enum_c;
+	NULL_t	*null	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	Int5_t	*int5_c	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Sequence_t;
+
+/*** <<< FUNC-DECLS [Sequence] >>> ***/
+
+/* extern asn_TYPE_descriptor_t asn_DEF_enum_c_6;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_Sequence;
+
+/*** <<< CODE [Sequence] >>> ***/
+
+static int
+enum_c_6_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;
+	return td->check_constraints(td, sptr, app_errlog, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+enum_c_6_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;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+static void
+enum_c_6_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+static int
+enum_c_6_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+static asn_dec_rval_t
+enum_c_6_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+static asn_enc_rval_t
+enum_c_6_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) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+static asn_dec_rval_t
+enum_c_6_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+static asn_enc_rval_t
+enum_c_6_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) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static asn_dec_rval_t
+enum_c_6_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static int
+memb_int1_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int1_t *st = (const Int1_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= -2)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_int4_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int4_t *st = (const Int4_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 5 && value <= 7)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_int5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const Int5_t *st = (const Int5_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value == 5)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+
+/*** <<< STAT-DEFS [Sequence] >>> ***/
+
+static int asn_DFL_2_set_3(void **sptr) {
+	Int1_t *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 3 */
+	return asn_long2INTEGER(st, 3);
+}
+static int asn_DFL_5_set_1(void **sptr) {
+	BOOLEAN_t *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 1 */
+	*st = 1;
+	return 0;
+}
+static asn_INTEGER_enum_map_t asn_MAP_enum_c_value2enum_6[] = {
+	{ 1,	3,	"one" },
+	{ 2,	3,	"two" },
+	{ 3,	5,	"three" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_enum_c_enum2value_6[] = {
+	0,	/* one(1) */
+	2,	/* three(3) */
+	1	/* two(2) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_enum_c_specs_6 = {
+	asn_MAP_enum_c_value2enum_6,	/* "tag" => N; sorted by tag */
+	asn_MAP_enum_c_enum2value_6,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1	/* Strict enumeration */
+};
+static ber_tlv_tag_t asn_DEF_enum_c_tags_6[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+static asn_per_constraints_t asn_PER_enum_c_constr_6 = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0,  1 }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_enum_c_6 = {
+	"enum-c",
+	"enum-c",
+	enum_c_6_free,
+	enum_c_6_print,
+	enum_c_6_constraint,
+	enum_c_6_decode_ber,
+	enum_c_6_encode_der,
+	enum_c_6_decode_xer,
+	enum_c_6_encode_xer,
+	enum_c_6_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_enum_c_tags_6,
+	sizeof(asn_DEF_enum_c_tags_6)
+		/sizeof(asn_DEF_enum_c_tags_6[0]), /* 1 */
+	asn_DEF_enum_c_tags_6,	/* Same as above */
+	sizeof(asn_DEF_enum_c_tags_6)
+		/sizeof(asn_DEF_enum_c_tags_6[0]), /* 1 */
+	&asn_PER_enum_c_constr_6,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_enum_c_specs_6	/* Additional specs */
+};
+
+static asn_per_constraints_t asn_PER_memb_int1_c_constr_2 = {
+	{ APC_SEMI_CONSTRAINED,	-1, -1, -2,  0 }	/* (-2..MAX) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+static asn_per_constraints_t asn_PER_memb_int4_c_constr_4 = {
+	{ APC_CONSTRAINED,	 2,  2,  5,  7 }	/* (5..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+static asn_per_constraints_t asn_PER_memb_enum_c_constr_6 = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0,  1 }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+static asn_per_constraints_t asn_PER_memb_int5_c_constr_13 = {
+	{ APC_CONSTRAINED,	 0,  0,  5,  5 }	/* (5..5) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+static asn_TYPE_member_t asn_MBR_Sequence_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct Sequence, int1_c),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Int1,
+		.memb_constraints = memb_int1_c_constraint_1,
+		.per_constraints = &asn_PER_memb_int1_c_constr_2,
+		.default_value = asn_DFL_2_set_3,	/* DEFAULT 3 */
+		.name = "int1-c"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Sequence, int4),
+		.tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		.tag_mode = +1,	/* EXPLICIT tag at current level */
+		.type = &asn_DEF_Int4,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "int4"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Sequence, int4_c),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Int4,
+		.memb_constraints = memb_int4_c_constraint_1,
+		.per_constraints = &asn_PER_memb_int4_c_constr_4,
+		.default_value = 0,
+		.name = "int4-c"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Sequence, bool),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_BOOLEAN,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = asn_DFL_5_set_1,	/* DEFAULT 1 */
+		.name = "bool"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Sequence, enum_c),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_enum_c_6,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = &asn_PER_memb_enum_c_constr_6,
+		.default_value = 0,
+		.name = "enum-c"
+		},
+	{ ATF_POINTER, 2, offsetof(struct Sequence, null),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_NULL,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "null"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Sequence, int5_c),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Int5,
+		.memb_constraints = memb_int5_c_constraint_1,
+		.per_constraints = &asn_PER_memb_int5_c_constr_13,
+		.default_value = 0,
+		.name = "int5-c"
+		},
+};
+static int asn_MAP_Sequence_oms_1[] = { 0, 3, 5, 6 };
+static ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 3, 0, 0 }, /* bool at 59 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 2 }, /* int1-c at 56 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 1 }, /* int4-c at 58 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 6, -2, 0 }, /* int5-c at 62 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 5, 0, 0 }, /* null at 64 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 4, 0, 0 }, /* enum-c at 60 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 } /* int4 at 57 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
+	sizeof(struct Sequence),
+	offsetof(struct Sequence, _asn_ctx),
+	asn_MAP_Sequence_tag2el_1,
+	7,	/* Count of tags in the map */
+	asn_MAP_Sequence_oms_1,	/* Optional members */
+	3, 1,	/* Root/Additions */
+	5,	/* Start extensions */
+	8	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Sequence = {
+	"Sequence",
+	"Sequence",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Sequence_tags_1,
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	asn_DEF_Sequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Sequence_1,
+	7,	/* Elements count */
+	&asn_SPC_Sequence_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [SequenceOf] >>> ***/
+
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+/*** <<< FWD-DECLS [SequenceOf] >>> ***/
+
+struct Sequence;
+
+/*** <<< TYPE-DECLS [SequenceOf] >>> ***/
+
+typedef struct SequenceOf {
+	A_SEQUENCE_OF(struct Sequence) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} SequenceOf_t;
+
+/*** <<< FUNC-DECLS [SequenceOf] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_SequenceOf;
+
+/*** <<< POST-INCLUDE [SequenceOf] >>> ***/
+
+#include <Sequence.h>
+
+/*** <<< STAT-DEFS [SequenceOf] >>> ***/
+
+static asn_TYPE_member_t asn_MBR_SequenceOf_1[] = {
+	{ ATF_POINTER, 0, 0,
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_Sequence,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = ""
+		},
+};
+static ber_tlv_tag_t asn_DEF_SequenceOf_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SequenceOf_specs_1 = {
+	sizeof(struct SequenceOf),
+	offsetof(struct SequenceOf, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static asn_per_constraints_t asn_PER_SequenceOf_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 1,  1,  1,  2 }	/* (SIZE(1..2)) */
+};
+asn_TYPE_descriptor_t asn_DEF_SequenceOf = {
+	"SequenceOf",
+	"SequenceOf",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SequenceOf_tags_1,
+	sizeof(asn_DEF_SequenceOf_tags_1)
+		/sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */
+	asn_DEF_SequenceOf_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SequenceOf_tags_1)
+		/sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */
+	&asn_PER_SequenceOf_constr_1,
+	asn_MBR_SequenceOf_1,
+	1,	/* Single element */
+	&asn_SPC_SequenceOf_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Enum0] >>> ***/
+
+#include <ENUMERATED.h>
+
+/*** <<< DEPS [Enum0] >>> ***/
+
+typedef enum Enum0 {
+	Enum0_one	= 0,
+	Enum0_two	= 1
+} Enum0_e;
+
+/*** <<< TYPE-DECLS [Enum0] >>> ***/
+
+typedef ENUMERATED_t	 Enum0_t;
+
+/*** <<< FUNC-DECLS [Enum0] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum0;
+asn_struct_free_f Enum0_free;
+asn_struct_print_f Enum0_print;
+asn_constr_check_f Enum0_constraint;
+ber_type_decoder_f Enum0_decode_ber;
+der_type_encoder_f Enum0_encode_der;
+xer_type_decoder_f Enum0_decode_xer;
+xer_type_encoder_f Enum0_encode_xer;
+per_type_decoder_f Enum0_decode_uper;
+
+/*** <<< CODE [Enum0] >>> ***/
+
+int
+Enum0_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;
+	return td->check_constraints(td, sptr, app_errlog, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum0_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;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+Enum0_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum0_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum0_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum0_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) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum0_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum0_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) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum0_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Enum0] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum0_value2enum_1[] = {
+	{ 0,	3,	"one" },
+	{ 1,	3,	"two" }
+};
+static unsigned int asn_MAP_Enum0_enum2value_1[] = {
+	0,	/* one(0) */
+	1	/* two(1) */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum0_specs_1 = {
+	asn_MAP_Enum0_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum0_enum2value_1,	/* 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_Enum0_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+static asn_per_constraints_t asn_PER_Enum0_constr_1 = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Enum0 = {
+	"Enum0",
+	"Enum0",
+	Enum0_free,
+	Enum0_print,
+	Enum0_constraint,
+	Enum0_decode_ber,
+	Enum0_encode_der,
+	Enum0_decode_xer,
+	Enum0_encode_xer,
+	Enum0_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum0_tags_1,
+	sizeof(asn_DEF_Enum0_tags_1)
+		/sizeof(asn_DEF_Enum0_tags_1[0]), /* 1 */
+	asn_DEF_Enum0_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum0_tags_1)
+		/sizeof(asn_DEF_Enum0_tags_1[0]), /* 1 */
+	&asn_PER_Enum0_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum0_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Enum1] >>> ***/
+
+#include <NativeEnumerated.h>
+
+/*** <<< DEPS [Enum1] >>> ***/
+
+typedef enum Enum1 {
+	Enum1_one	= 0,
+	Enum1_two	= 1
+} Enum1_e;
+
+/*** <<< TYPE-DECLS [Enum1] >>> ***/
+
+typedef long	 Enum1_t;
+
+/*** <<< FUNC-DECLS [Enum1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum1;
+asn_struct_free_f Enum1_free;
+asn_struct_print_f Enum1_print;
+asn_constr_check_f Enum1_constraint;
+ber_type_decoder_f Enum1_decode_ber;
+der_type_encoder_f Enum1_encode_der;
+xer_type_decoder_f Enum1_decode_xer;
+xer_type_encoder_f Enum1_encode_xer;
+per_type_decoder_f Enum1_decode_uper;
+
+/*** <<< CODE [Enum1] >>> ***/
+
+int
+Enum1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value == 0)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+Enum1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum1_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) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum1_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) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Enum1] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum1_value2enum_1[] = {
+	{ 0,	3,	"one" },
+	{ 1,	3,	"two" }
+};
+static unsigned int asn_MAP_Enum1_enum2value_1[] = {
+	0,	/* one(0) */
+	1	/* two(1) */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum1_specs_1 = {
+	asn_MAP_Enum1_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum1_enum2value_1,	/* 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_Enum1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+static asn_per_constraints_t asn_PER_Enum1_constr_1 = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Enum1 = {
+	"Enum1",
+	"Enum1",
+	Enum1_free,
+	Enum1_print,
+	Enum1_constraint,
+	Enum1_decode_ber,
+	Enum1_encode_der,
+	Enum1_decode_xer,
+	Enum1_encode_xer,
+	Enum1_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum1_tags_1,
+	sizeof(asn_DEF_Enum1_tags_1)
+		/sizeof(asn_DEF_Enum1_tags_1[0]), /* 1 */
+	asn_DEF_Enum1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum1_tags_1)
+		/sizeof(asn_DEF_Enum1_tags_1[0]), /* 1 */
+	&asn_PER_Enum1_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum1_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Identifier] >>> ***/
+
+#include <VisibleString.h>
+
+/*** <<< TYPE-DECLS [Identifier] >>> ***/
+
+typedef VisibleString_t	 Identifier_t;
+
+/*** <<< FUNC-DECLS [Identifier] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Identifier;
+asn_struct_free_f Identifier_free;
+asn_struct_print_f Identifier_print;
+asn_constr_check_f Identifier_constraint;
+ber_type_decoder_f Identifier_decode_ber;
+der_type_encoder_f Identifier_encode_der;
+xer_type_decoder_f Identifier_decode_xer;
+xer_type_encoder_f Identifier_encode_xer;
+per_type_decoder_f Identifier_decode_uper;
+
+/*** <<< CTABLES [Identifier] >>> ***/
+
+static int permitted_alphabet_table_1[256] = {
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/*                  */
+0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,	/*     $            */
+1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,	/* 0123456789       */
+0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,	/*  ABCDEFGHIJKLMNO */
+1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,	/* PQRSTUVWXYZ    _ */
+0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,	/*  abcdefghijklmno */
+1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,	/* pqrstuvwxyz      */
+};
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	int *table = permitted_alphabet_table_1;
+	/* The underlying type is VisibleString */
+	const VisibleString_t *st = (const VisibleString_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!table[cv]) return -1;
+	}
+	return 0;
+}
+
+
+/*** <<< CODE [Identifier] >>> ***/
+
+int
+Identifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const VisibleString_t *st = (const VisibleString_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 32)
+		 && !check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using VisibleString,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Identifier_1_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;
+	td->der_encoder    = asn_DEF_VisibleString.der_encoder;
+	td->xer_decoder    = asn_DEF_VisibleString.xer_decoder;
+	td->xer_encoder    = asn_DEF_VisibleString.xer_encoder;
+	td->uper_decoder   = asn_DEF_VisibleString.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_VisibleString.per_constraints;
+	td->elements       = asn_DEF_VisibleString.elements;
+	td->elements_count = asn_DEF_VisibleString.elements_count;
+	td->specifics      = asn_DEF_VisibleString.specifics;
+}
+
+void
+Identifier_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Identifier_1_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_1_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, const void *bufptr, size_t size, int tag_mode) {
+	Identifier_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+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_1_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, const void *bufptr, size_t size) {
+	Identifier_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+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_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Identifier_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Identifier_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [Identifier] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_Identifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (26 << 2))
+};
+static asn_per_constraints_t asn_PER_Identifier_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 5,  5,  1,  32 }	/* (SIZE(1..32)) */
+};
+asn_TYPE_descriptor_t asn_DEF_Identifier = {
+	"Identifier",
+	"Identifier",
+	Identifier_free,
+	Identifier_print,
+	Identifier_constraint,
+	Identifier_decode_ber,
+	Identifier_encode_der,
+	Identifier_decode_xer,
+	Identifier_encode_xer,
+	Identifier_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Identifier_tags_1,
+	sizeof(asn_DEF_Identifier_tags_1)
+		/sizeof(asn_DEF_Identifier_tags_1[0]), /* 1 */
+	asn_DEF_Identifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Identifier_tags_1)
+		/sizeof(asn_DEF_Identifier_tags_1[0]), /* 1 */
+	&asn_PER_Identifier_constr_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 2590eab..ad44cdd 100644
--- a/tests/59-choice-extended-OK.asn1.-P
+++ b/tests/59-choice-extended-OK.asn1.-P
@@ -52,6 +52,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.b),
@@ -59,6 +61,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice, choice.c),
@@ -66,25 +70,28 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Choice,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "c"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Choice_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Choice_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice_tag2el_1[] = {
     { (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_SPC_Choice_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice_specs_1 = {
 	sizeof(struct Choice),
 	offsetof(struct Choice, _asn_ctx),
 	offsetof(struct Choice, present),
 	sizeof(((struct Choice *)0)->present),
-	asn_MAP_Choice_1_tag2el,
+	asn_MAP_Choice_tag2el_1,
 	3,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice = {
 	"Choice",
@@ -96,15 +103,17 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
-	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_DEF_Choice_tags_1,
+	sizeof(asn_DEF_Choice_tags_1)
+		/sizeof(asn_DEF_Choice_tags_1[0]), /* 1 */
+	asn_DEF_Choice_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Choice_tags_1)
+		/sizeof(asn_DEF_Choice_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice_1,
 	3,	/* Elements count */
-	&asn_SPC_Choice_1_specs	/* Additional specs */
+	&asn_SPC_Choice_specs_1	/* Additional specs */
 };
 
diff --git a/tests/60-any-OK.asn1.-P b/tests/60-any-OK.asn1.-P
index 4d2f7e8..d385a4e 100644
--- a/tests/60-any-OK.asn1.-P
+++ b/tests/60-any-OK.asn1.-P
@@ -27,6 +27,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "i"
 		},
 	{ ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct T1, any),
@@ -34,20 +36,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_ANY,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "any"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T1_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T1_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* i at 15 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_T1_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T1_specs_1 = {
 	sizeof(struct T1),
 	offsetof(struct T1, _asn_ctx),
-	asn_MAP_T1_1_tag2el,
+	asn_MAP_T1_tag2el_1,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -61,16 +66,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T1_tags_1,
+	sizeof(asn_DEF_T1_tags_1)
+		/sizeof(asn_DEF_T1_tags_1[0]), /* 1 */
+	asn_DEF_T1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T1_tags_1)
+		/sizeof(asn_DEF_T1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T1_1,
 	2,	/* Elements count */
-	&asn_SPC_T1_1_specs	/* Additional specs */
+	&asn_SPC_T1_specs_1	/* Additional specs */
 };
 
 
@@ -102,6 +109,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "i"
 		},
 	{ ATF_POINTER, 1, offsetof(struct T2, any),
@@ -109,21 +118,24 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_ANY,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "any"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T2_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T2_tag2el_1[] = {
     { (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_SPC_T2_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T2_specs_1 = {
 	sizeof(struct T2),
 	offsetof(struct T2, _asn_ctx),
-	asn_MAP_T2_1_tag2el,
+	asn_MAP_T2_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -137,16 +149,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T2_tags_1,
+	sizeof(asn_DEF_T2_tags_1)
+		/sizeof(asn_DEF_T2_tags_1[0]), /* 1 */
+	asn_DEF_T2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T2_tags_1)
+		/sizeof(asn_DEF_T2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T2_1,
 	2,	/* Elements count */
-	&asn_SPC_T2_1_specs	/* Additional specs */
+	&asn_SPC_T2_specs_1	/* Additional specs */
 };
 
 
@@ -177,6 +191,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_ANY,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "any1"
 		},
 	{ ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct T3, any2),
@@ -184,17 +200,20 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_ANY,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "any2"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SEQUENCE_specifics_t asn_SPC_T3_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T3_specs_1 = {
 	sizeof(struct T3),
 	offsetof(struct T3, _asn_ctx),
 	0,	/* No top level tags */
 	0,	/* No tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -208,15 +227,17 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T3_1_tags,
-	sizeof(asn_DEF_T3_1_tags)
-		/sizeof(asn_DEF_T3_1_tags[0]), /* 1 */
-	asn_DEF_T3_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T3_1_tags)
-		/sizeof(asn_DEF_T3_1_tags[0]), /* 1 */
+	asn_DEF_T3_tags_1,
+	sizeof(asn_DEF_T3_tags_1)
+		/sizeof(asn_DEF_T3_tags_1[0]), /* 1 */
+	asn_DEF_T3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T3_tags_1)
+		/sizeof(asn_DEF_T3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T3_1,
 	2,	/* Elements count */
-	&asn_SPC_T3_1_specs	/* Additional specs */
+	&asn_SPC_T3_specs_1	/* Additional specs */
 };
 
diff --git a/tests/65-multi-tag-OK.asn1.-P b/tests/65-multi-tag-OK.asn1.-P
index 25a449d..f4b3907 100644
--- a/tests/65-multi-tag-OK.asn1.-P
+++ b/tests/65-multi-tag-OK.asn1.-P
@@ -40,6 +40,9 @@
 	td->der_encoder    = asn_DEF_T2.der_encoder;
 	td->xer_decoder    = asn_DEF_T2.xer_decoder;
 	td->xer_encoder    = asn_DEF_T2.xer_encoder;
+	td->uper_decoder   = asn_DEF_T2.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T2.per_constraints;
 	td->elements       = asn_DEF_T2.elements;
 	td->elements_count = asn_DEF_T2.elements_count;
 	td->specifics      = asn_DEF_T2.specifics;
@@ -92,13 +95,13 @@
 
 /*** <<< STAT-DEFS [T1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_tags_1[] = {
 	(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_1_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_all_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
@@ -116,13 +119,15 @@
 	T1_encode_der,
 	T1_decode_xer,
 	T1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T1_1_tags,
-	sizeof(asn_DEF_T1_1_tags)
-		/sizeof(asn_DEF_T1_1_tags[0]), /* 4 */
-	asn_DEF_T1_1_all_tags,
-	sizeof(asn_DEF_T1_1_all_tags)
-		/sizeof(asn_DEF_T1_1_all_tags[0]), /* 6 */
+	asn_DEF_T1_tags_1,
+	sizeof(asn_DEF_T1_tags_1)
+		/sizeof(asn_DEF_T1_tags_1[0]), /* 4 */
+	asn_DEF_T1_all_tags_1,
+	sizeof(asn_DEF_T1_all_tags_1)
+		/sizeof(asn_DEF_T1_all_tags_1[0]), /* 6 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -169,6 +174,9 @@
 	td->der_encoder    = asn_DEF_T3.der_encoder;
 	td->xer_decoder    = asn_DEF_T3.xer_decoder;
 	td->xer_encoder    = asn_DEF_T3.xer_encoder;
+	td->uper_decoder   = asn_DEF_T3.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T3.per_constraints;
 	td->elements       = asn_DEF_T3.elements;
 	td->elements_count = asn_DEF_T3.elements_count;
 	td->specifics      = asn_DEF_T3.specifics;
@@ -221,12 +229,12 @@
 
 /*** <<< STAT-DEFS [T2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_tags_1[] = {
 	(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_1_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_all_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
@@ -243,13 +251,15 @@
 	T2_encode_der,
 	T2_decode_xer,
 	T2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T2_1_tags,
-	sizeof(asn_DEF_T2_1_tags)
-		/sizeof(asn_DEF_T2_1_tags[0]), /* 3 */
-	asn_DEF_T2_1_all_tags,
-	sizeof(asn_DEF_T2_1_all_tags)
-		/sizeof(asn_DEF_T2_1_all_tags[0]), /* 5 */
+	asn_DEF_T2_tags_1,
+	sizeof(asn_DEF_T2_tags_1)
+		/sizeof(asn_DEF_T2_tags_1[0]), /* 3 */
+	asn_DEF_T2_all_tags_1,
+	sizeof(asn_DEF_T2_all_tags_1)
+		/sizeof(asn_DEF_T2_all_tags_1[0]), /* 5 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -296,6 +306,9 @@
 	td->der_encoder    = asn_DEF_T4.der_encoder;
 	td->xer_decoder    = asn_DEF_T4.xer_decoder;
 	td->xer_encoder    = asn_DEF_T4.xer_encoder;
+	td->uper_decoder   = asn_DEF_T4.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T4.per_constraints;
 	td->elements       = asn_DEF_T4.elements;
 	td->elements_count = asn_DEF_T4.elements_count;
 	td->specifics      = asn_DEF_T4.specifics;
@@ -348,11 +361,11 @@
 
 /*** <<< STAT-DEFS [T3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2))
 };
-static ber_tlv_tag_t asn_DEF_T3_1_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_all_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
@@ -368,13 +381,15 @@
 	T3_encode_der,
 	T3_decode_xer,
 	T3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T3_1_tags,
-	sizeof(asn_DEF_T3_1_tags)
-		/sizeof(asn_DEF_T3_1_tags[0]), /* 2 */
-	asn_DEF_T3_1_all_tags,
-	sizeof(asn_DEF_T3_1_all_tags)
-		/sizeof(asn_DEF_T3_1_all_tags[0]), /* 4 */
+	asn_DEF_T3_tags_1,
+	sizeof(asn_DEF_T3_tags_1)
+		/sizeof(asn_DEF_T3_tags_1[0]), /* 2 */
+	asn_DEF_T3_all_tags_1,
+	sizeof(asn_DEF_T3_all_tags_1)
+		/sizeof(asn_DEF_T3_all_tags_1[0]), /* 4 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -421,6 +436,9 @@
 	td->der_encoder    = asn_DEF_T5.der_encoder;
 	td->xer_decoder    = asn_DEF_T5.xer_decoder;
 	td->xer_encoder    = asn_DEF_T5.xer_encoder;
+	td->uper_decoder   = asn_DEF_T5.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T5.per_constraints;
 	td->elements       = asn_DEF_T5.elements;
 	td->elements_count = asn_DEF_T5.elements_count;
 	td->specifics      = asn_DEF_T5.specifics;
@@ -473,7 +491,7 @@
 
 /*** <<< STAT-DEFS [T4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T4_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T4_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
@@ -488,13 +506,15 @@
 	T4_encode_der,
 	T4_decode_xer,
 	T4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T4_1_tags,
-	sizeof(asn_DEF_T4_1_tags)
-		/sizeof(asn_DEF_T4_1_tags[0]) - 1, /* 2 */
-	asn_DEF_T4_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T4_1_tags)
-		/sizeof(asn_DEF_T4_1_tags[0]), /* 3 */
+	asn_DEF_T4_tags_1,
+	sizeof(asn_DEF_T4_tags_1)
+		/sizeof(asn_DEF_T4_tags_1[0]) - 1, /* 2 */
+	asn_DEF_T4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T4_tags_1)
+		/sizeof(asn_DEF_T4_tags_1[0]), /* 3 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -541,6 +561,9 @@
 	td->der_encoder    = asn_DEF_T6.der_encoder;
 	td->xer_decoder    = asn_DEF_T6.xer_decoder;
 	td->xer_encoder    = asn_DEF_T6.xer_encoder;
+	td->uper_decoder   = asn_DEF_T6.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T6.per_constraints;
 	td->elements       = asn_DEF_T6.elements;
 	td->elements_count = asn_DEF_T6.elements_count;
 	td->specifics      = asn_DEF_T6.specifics;
@@ -593,7 +616,7 @@
 
 /*** <<< STAT-DEFS [T5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T5_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T5_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 };
@@ -607,13 +630,15 @@
 	T5_encode_der,
 	T5_decode_xer,
 	T5_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T5_1_tags,
-	sizeof(asn_DEF_T5_1_tags)
-		/sizeof(asn_DEF_T5_1_tags[0]) - 1, /* 1 */
-	asn_DEF_T5_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T5_1_tags)
-		/sizeof(asn_DEF_T5_1_tags[0]), /* 2 */
+	asn_DEF_T5_tags_1,
+	sizeof(asn_DEF_T5_tags_1)
+		/sizeof(asn_DEF_T5_tags_1[0]) - 1, /* 1 */
+	asn_DEF_T5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T5_tags_1)
+		/sizeof(asn_DEF_T5_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -660,6 +685,9 @@
 	td->der_encoder    = asn_DEF_REAL.der_encoder;
 	td->xer_decoder    = asn_DEF_REAL.xer_decoder;
 	td->xer_encoder    = asn_DEF_REAL.xer_encoder;
+	td->uper_decoder   = asn_DEF_REAL.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_REAL.per_constraints;
 	td->elements       = asn_DEF_REAL.elements;
 	td->elements_count = asn_DEF_REAL.elements_count;
 	td->specifics      = asn_DEF_REAL.specifics;
@@ -712,7 +740,7 @@
 
 /*** <<< STAT-DEFS [T6] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T6_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T6_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_T6 = {
@@ -725,13 +753,15 @@
 	T6_encode_der,
 	T6_decode_xer,
 	T6_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T6_1_tags,
-	sizeof(asn_DEF_T6_1_tags)
-		/sizeof(asn_DEF_T6_1_tags[0]), /* 1 */
-	asn_DEF_T6_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T6_1_tags)
-		/sizeof(asn_DEF_T6_1_tags[0]), /* 1 */
+	asn_DEF_T6_tags_1,
+	sizeof(asn_DEF_T6_tags_1)
+		/sizeof(asn_DEF_T6_tags_1[0]), /* 1 */
+	asn_DEF_T6_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T6_tags_1)
+		/sizeof(asn_DEF_T6_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -778,6 +808,9 @@
 	td->der_encoder    = asn_DEF_Ts.der_encoder;
 	td->xer_decoder    = asn_DEF_Ts.xer_decoder;
 	td->xer_encoder    = asn_DEF_Ts.xer_encoder;
+	td->uper_decoder   = asn_DEF_Ts.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Ts.per_constraints;
 	td->elements       = asn_DEF_Ts.elements;
 	td->elements_count = asn_DEF_Ts.elements_count;
 	td->specifics      = asn_DEF_Ts.specifics;
@@ -830,7 +863,7 @@
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
@@ -845,13 +878,15 @@
 	T_encode_der,
 	T_decode_xer,
 	T_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_1_tags,
-	sizeof(asn_DEF_T_1_tags)
-		/sizeof(asn_DEF_T_1_tags[0]) - 2, /* 1 */
-	asn_DEF_T_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T_1_tags)
-		/sizeof(asn_DEF_T_1_tags[0]), /* 3 */
+	asn_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]) - 2, /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 3 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -886,6 +921,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_T2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m1"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Ts, m2),
@@ -893,6 +930,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_T3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m2"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Ts, m3),
@@ -900,23 +939,26 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_T3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m3"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Ts_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Ts_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Ts_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Ts_tag2el_1[] = {
     { (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_SPC_Ts_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Ts_specs_1 = {
 	sizeof(struct Ts),
 	offsetof(struct Ts, _asn_ctx),
-	asn_MAP_Ts_1_tag2el,
+	asn_MAP_Ts_tag2el_1,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -930,15 +972,17 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Ts_tags_1,
+	sizeof(asn_DEF_Ts_tags_1)
+		/sizeof(asn_DEF_Ts_tags_1[0]) - 1, /* 1 */
+	asn_DEF_Ts_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Ts_tags_1)
+		/sizeof(asn_DEF_Ts_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Ts_1,
 	3,	/* Elements count */
-	&asn_SPC_Ts_1_specs	/* Additional specs */
+	&asn_SPC_Ts_specs_1	/* Additional specs */
 };
 
diff --git a/tests/65-multi-tag-OK.asn1.-Pfnative-types b/tests/65-multi-tag-OK.asn1.-Pfnative-types
index 04a044e..fd5b46f 100644
--- a/tests/65-multi-tag-OK.asn1.-Pfnative-types
+++ b/tests/65-multi-tag-OK.asn1.-Pfnative-types
@@ -40,6 +40,9 @@
 	td->der_encoder    = asn_DEF_T2.der_encoder;
 	td->xer_decoder    = asn_DEF_T2.xer_decoder;
 	td->xer_encoder    = asn_DEF_T2.xer_encoder;
+	td->uper_decoder   = asn_DEF_T2.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T2.per_constraints;
 	td->elements       = asn_DEF_T2.elements;
 	td->elements_count = asn_DEF_T2.elements_count;
 	td->specifics      = asn_DEF_T2.specifics;
@@ -92,13 +95,13 @@
 
 /*** <<< STAT-DEFS [T1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_tags_1[] = {
 	(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_1_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T1_all_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
@@ -116,13 +119,15 @@
 	T1_encode_der,
 	T1_decode_xer,
 	T1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T1_1_tags,
-	sizeof(asn_DEF_T1_1_tags)
-		/sizeof(asn_DEF_T1_1_tags[0]), /* 4 */
-	asn_DEF_T1_1_all_tags,
-	sizeof(asn_DEF_T1_1_all_tags)
-		/sizeof(asn_DEF_T1_1_all_tags[0]), /* 6 */
+	asn_DEF_T1_tags_1,
+	sizeof(asn_DEF_T1_tags_1)
+		/sizeof(asn_DEF_T1_tags_1[0]), /* 4 */
+	asn_DEF_T1_all_tags_1,
+	sizeof(asn_DEF_T1_all_tags_1)
+		/sizeof(asn_DEF_T1_all_tags_1[0]), /* 6 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -169,6 +174,9 @@
 	td->der_encoder    = asn_DEF_T3.der_encoder;
 	td->xer_decoder    = asn_DEF_T3.xer_decoder;
 	td->xer_encoder    = asn_DEF_T3.xer_encoder;
+	td->uper_decoder   = asn_DEF_T3.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T3.per_constraints;
 	td->elements       = asn_DEF_T3.elements;
 	td->elements_count = asn_DEF_T3.elements_count;
 	td->specifics      = asn_DEF_T3.specifics;
@@ -221,12 +229,12 @@
 
 /*** <<< STAT-DEFS [T2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_tags_1[] = {
 	(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_1_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T2_all_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
@@ -243,13 +251,15 @@
 	T2_encode_der,
 	T2_decode_xer,
 	T2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T2_1_tags,
-	sizeof(asn_DEF_T2_1_tags)
-		/sizeof(asn_DEF_T2_1_tags[0]), /* 3 */
-	asn_DEF_T2_1_all_tags,
-	sizeof(asn_DEF_T2_1_all_tags)
-		/sizeof(asn_DEF_T2_1_all_tags[0]), /* 5 */
+	asn_DEF_T2_tags_1,
+	sizeof(asn_DEF_T2_tags_1)
+		/sizeof(asn_DEF_T2_tags_1[0]), /* 3 */
+	asn_DEF_T2_all_tags_1,
+	sizeof(asn_DEF_T2_all_tags_1)
+		/sizeof(asn_DEF_T2_all_tags_1[0]), /* 5 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -296,6 +306,9 @@
 	td->der_encoder    = asn_DEF_T4.der_encoder;
 	td->xer_decoder    = asn_DEF_T4.xer_decoder;
 	td->xer_encoder    = asn_DEF_T4.xer_encoder;
+	td->uper_decoder   = asn_DEF_T4.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T4.per_constraints;
 	td->elements       = asn_DEF_T4.elements;
 	td->elements_count = asn_DEF_T4.elements_count;
 	td->specifics      = asn_DEF_T4.specifics;
@@ -348,11 +361,11 @@
 
 /*** <<< STAT-DEFS [T3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2))
 };
-static ber_tlv_tag_t asn_DEF_T3_1_all_tags[] = {
+static ber_tlv_tag_t asn_DEF_T3_all_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
@@ -368,13 +381,15 @@
 	T3_encode_der,
 	T3_decode_xer,
 	T3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T3_1_tags,
-	sizeof(asn_DEF_T3_1_tags)
-		/sizeof(asn_DEF_T3_1_tags[0]), /* 2 */
-	asn_DEF_T3_1_all_tags,
-	sizeof(asn_DEF_T3_1_all_tags)
-		/sizeof(asn_DEF_T3_1_all_tags[0]), /* 4 */
+	asn_DEF_T3_tags_1,
+	sizeof(asn_DEF_T3_tags_1)
+		/sizeof(asn_DEF_T3_tags_1[0]), /* 2 */
+	asn_DEF_T3_all_tags_1,
+	sizeof(asn_DEF_T3_all_tags_1)
+		/sizeof(asn_DEF_T3_all_tags_1[0]), /* 4 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -421,6 +436,9 @@
 	td->der_encoder    = asn_DEF_T5.der_encoder;
 	td->xer_decoder    = asn_DEF_T5.xer_decoder;
 	td->xer_encoder    = asn_DEF_T5.xer_encoder;
+	td->uper_decoder   = asn_DEF_T5.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T5.per_constraints;
 	td->elements       = asn_DEF_T5.elements;
 	td->elements_count = asn_DEF_T5.elements_count;
 	td->specifics      = asn_DEF_T5.specifics;
@@ -473,7 +491,7 @@
 
 /*** <<< STAT-DEFS [T4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T4_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T4_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
@@ -488,13 +506,15 @@
 	T4_encode_der,
 	T4_decode_xer,
 	T4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T4_1_tags,
-	sizeof(asn_DEF_T4_1_tags)
-		/sizeof(asn_DEF_T4_1_tags[0]) - 1, /* 2 */
-	asn_DEF_T4_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T4_1_tags)
-		/sizeof(asn_DEF_T4_1_tags[0]), /* 3 */
+	asn_DEF_T4_tags_1,
+	sizeof(asn_DEF_T4_tags_1)
+		/sizeof(asn_DEF_T4_tags_1[0]) - 1, /* 2 */
+	asn_DEF_T4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T4_tags_1)
+		/sizeof(asn_DEF_T4_tags_1[0]), /* 3 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -541,6 +561,9 @@
 	td->der_encoder    = asn_DEF_T6.der_encoder;
 	td->xer_decoder    = asn_DEF_T6.xer_decoder;
 	td->xer_encoder    = asn_DEF_T6.xer_encoder;
+	td->uper_decoder   = asn_DEF_T6.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_T6.per_constraints;
 	td->elements       = asn_DEF_T6.elements;
 	td->elements_count = asn_DEF_T6.elements_count;
 	td->specifics      = asn_DEF_T6.specifics;
@@ -593,7 +616,7 @@
 
 /*** <<< STAT-DEFS [T5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T5_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T5_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 };
@@ -607,13 +630,15 @@
 	T5_encode_der,
 	T5_decode_xer,
 	T5_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T5_1_tags,
-	sizeof(asn_DEF_T5_1_tags)
-		/sizeof(asn_DEF_T5_1_tags[0]) - 1, /* 1 */
-	asn_DEF_T5_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T5_1_tags)
-		/sizeof(asn_DEF_T5_1_tags[0]), /* 2 */
+	asn_DEF_T5_tags_1,
+	sizeof(asn_DEF_T5_tags_1)
+		/sizeof(asn_DEF_T5_tags_1[0]) - 1, /* 1 */
+	asn_DEF_T5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T5_tags_1)
+		/sizeof(asn_DEF_T5_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -660,6 +685,9 @@
 	td->der_encoder    = asn_DEF_NativeReal.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeReal.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeReal.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeReal.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeReal.per_constraints;
 	td->elements       = asn_DEF_NativeReal.elements;
 	td->elements_count = asn_DEF_NativeReal.elements_count;
 	td->specifics      = asn_DEF_NativeReal.specifics;
@@ -712,7 +740,7 @@
 
 /*** <<< STAT-DEFS [T6] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T6_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T6_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_T6 = {
@@ -725,13 +753,15 @@
 	T6_encode_der,
 	T6_decode_xer,
 	T6_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T6_1_tags,
-	sizeof(asn_DEF_T6_1_tags)
-		/sizeof(asn_DEF_T6_1_tags[0]), /* 1 */
-	asn_DEF_T6_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T6_1_tags)
-		/sizeof(asn_DEF_T6_1_tags[0]), /* 1 */
+	asn_DEF_T6_tags_1,
+	sizeof(asn_DEF_T6_tags_1)
+		/sizeof(asn_DEF_T6_tags_1[0]), /* 1 */
+	asn_DEF_T6_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T6_tags_1)
+		/sizeof(asn_DEF_T6_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -778,6 +808,9 @@
 	td->der_encoder    = asn_DEF_Ts.der_encoder;
 	td->xer_decoder    = asn_DEF_Ts.xer_decoder;
 	td->xer_encoder    = asn_DEF_Ts.xer_encoder;
+	td->uper_decoder   = asn_DEF_Ts.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Ts.per_constraints;
 	td->elements       = asn_DEF_Ts.elements;
 	td->elements_count = asn_DEF_Ts.elements_count;
 	td->specifics      = asn_DEF_Ts.specifics;
@@ -830,7 +863,7 @@
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
@@ -845,13 +878,15 @@
 	T_encode_der,
 	T_decode_xer,
 	T_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_T_1_tags,
-	sizeof(asn_DEF_T_1_tags)
-		/sizeof(asn_DEF_T_1_tags[0]) - 2, /* 1 */
-	asn_DEF_T_1_tags,	/* Same as above */
-	sizeof(asn_DEF_T_1_tags)
-		/sizeof(asn_DEF_T_1_tags[0]), /* 3 */
+	asn_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]) - 2, /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 3 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -886,6 +921,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_T2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m1"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Ts, m2),
@@ -893,6 +930,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_T3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m2"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Ts, m3),
@@ -900,23 +939,26 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_T3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m3"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Ts_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Ts_tags_1[] = {
 	(ASN_TAG_CLASS_CONTEXT | (123 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Ts_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Ts_tag2el_1[] = {
     { (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_SPC_Ts_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Ts_specs_1 = {
 	sizeof(struct Ts),
 	offsetof(struct Ts, _asn_ctx),
-	asn_MAP_Ts_1_tag2el,
+	asn_MAP_Ts_tag2el_1,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -930,15 +972,17 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Ts_tags_1,
+	sizeof(asn_DEF_Ts_tags_1)
+		/sizeof(asn_DEF_Ts_tags_1[0]) - 1, /* 1 */
+	asn_DEF_Ts_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Ts_tags_1)
+		/sizeof(asn_DEF_Ts_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Ts_1,
 	3,	/* Elements count */
-	&asn_SPC_Ts_1_specs	/* Additional specs */
+	&asn_SPC_Ts_specs_1	/* Additional specs */
 };
 
diff --git a/tests/66-ref-simple-OK.asn1.-P b/tests/66-ref-simple-OK.asn1.-P
index 121e6c8..1e6f4ed 100644
--- a/tests/66-ref-simple-OK.asn1.-P
+++ b/tests/66-ref-simple-OK.asn1.-P
@@ -26,13 +26,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_SimpleType,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "named"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_T_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_T_specs_1 = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -47,16 +49,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T_1,
 	1,	/* Single element */
-	&asn_SPC_T_1_specs	/* Additional specs */
+	&asn_SPC_T_specs_1	/* Additional specs */
 };
 
 
@@ -109,6 +113,9 @@
 	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
 	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
 	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
 	td->elements       = asn_DEF_ENUMERATED.elements;
 	td->elements_count = asn_DEF_ENUMERATED.elements_count;
      /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
@@ -161,24 +168,24 @@
 
 /*** <<< STAT-DEFS [SimpleType] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_SimpleType_1_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_SimpleType_value2enum_1[] = {
 	{ 0,	3,	"one" },
 	{ 1,	3,	"two" },
 	{ 2,	5,	"three" }
 };
-static unsigned int asn_MAP_SimpleType_1_enum2value[] = {
+static unsigned int asn_MAP_SimpleType_enum2value_1[] = {
 	0,	/* one(0) */
 	2,	/* three(2) */
 	1	/* two(1) */
 };
-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 */
+static asn_INTEGER_specifics_t asn_SPC_SimpleType_specs_1 = {
+	asn_MAP_SimpleType_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SimpleType_enum2value_1,	/* 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_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SimpleType_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_SimpleType = {
@@ -191,14 +198,16 @@
 	SimpleType_encode_der,
 	SimpleType_decode_xer,
 	SimpleType_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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 */
+	asn_DEF_SimpleType_tags_1,
+	sizeof(asn_DEF_SimpleType_tags_1)
+		/sizeof(asn_DEF_SimpleType_tags_1[0]), /* 1 */
+	asn_DEF_SimpleType_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SimpleType_tags_1)
+		/sizeof(asn_DEF_SimpleType_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
-	&asn_SPC_SimpleType_1_specs	/* Additional specs */
+	&asn_SPC_SimpleType_specs_1	/* Additional specs */
 };
 
diff --git a/tests/69-reserved-words-OK.asn1.-P b/tests/69-reserved-words-OK.asn1.-P
index d7582cd..897295d 100644
--- a/tests/69-reserved-words-OK.asn1.-P
+++ b/tests/69-reserved-words-OK.asn1.-P
@@ -47,7 +47,7 @@
 /*** <<< CODE [T] >>> ***/
 
 static int
-memb_char_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_char_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
 	size_t size;
@@ -75,22 +75,22 @@
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_class_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_class_tags_4[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static uint8_t asn_MAP_class_4_mmap[(0 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_class_mmap_4[(0 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	0
 };
-static asn_SET_specifics_t asn_SPC_class_4_specs = {
+static asn_SET_specifics_t asn_SPC_class_specs_4 = {
 	sizeof(struct Class),
 	offsetof(struct Class, _asn_ctx),
 	offsetof(struct Class, _presence_map),
-	asn_MAP_class_4_tag2el,
+	asn_MAP_class_tag2el_4,
 	0,	/* Count of tags in the map */
-	asn_MAP_class_4_tag2el,	/* Same as above */
+	asn_MAP_class_tag2el_4,	/* Same as above */
 	0,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_MAP_class_4_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_class_mmap_4	/* Mandatory elements map */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_class_4 = {
@@ -103,15 +103,17 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_class_4_tags,
-	sizeof(asn_DEF_class_4_tags)
-		/sizeof(asn_DEF_class_4_tags[0]), /* 1 */
-	asn_DEF_class_4_tags,	/* Same as above */
-	sizeof(asn_DEF_class_4_tags)
-		/sizeof(asn_DEF_class_4_tags[0]), /* 1 */
+	asn_DEF_class_tags_4,
+	sizeof(asn_DEF_class_tags_4)
+		/sizeof(asn_DEF_class_tags_4[0]), /* 1 */
+	asn_DEF_class_tags_4,	/* Same as above */
+	sizeof(asn_DEF_class_tags_4)
+		/sizeof(asn_DEF_class_tags_4[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
-	&asn_SPC_class_4_specs	/* Additional specs */
+	&asn_SPC_class_specs_4	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_T_1[] = {
@@ -120,13 +122,17 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "int"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct T, Char),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_OCTET_STRING,
-		.memb_constraints = memb_char_1_constraint,
+		.memb_constraints = memb_char_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "char"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct T, Class),
@@ -134,6 +140,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_class_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "class"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct T, Double),
@@ -141,23 +149,26 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_REAL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "double"
 		},
 };
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_tag2el_1[] = {
     { (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_SPC_T_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_T_specs_1 = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
-	asn_MAP_T_1_tag2el,
+	asn_MAP_T_tag2el_1,
 	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -171,15 +182,17 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_T_1,
 	4,	/* Elements count */
-	&asn_SPC_T_1_specs	/* Additional specs */
+	&asn_SPC_T_specs_1	/* Additional specs */
 };
 
diff --git a/tests/70-xer-test-OK.asn1.-P b/tests/70-xer-test-OK.asn1.-P
index 72483fd..45d6a69 100644
--- a/tests/70-xer-test-OK.asn1.-P
+++ b/tests/70-xer-test-OK.asn1.-P
@@ -82,6 +82,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "sequence"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.set),
@@ -89,6 +91,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.sequenceOf),
@@ -96,6 +100,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_SequenceOf,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "sequenceOf"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSet),
@@ -103,6 +109,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_ExtensibleSet,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "extensibleSet"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSequence),
@@ -110,6 +118,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_ExtensibleSequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "extensibleSequence"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSequence2),
@@ -117,6 +127,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_ExtensibleSequence2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "extensibleSequence2"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfNULL),
@@ -124,6 +136,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_SetOfNULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "setOfNULL"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfREAL),
@@ -131,6 +145,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_SetOfREAL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "setOfREAL"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfEnums),
@@ -138,6 +154,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_SetOfEnums,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "setOfEnums"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfNULL),
@@ -145,6 +163,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NamedSetOfNULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "namedSetOfNULL"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfREAL),
@@ -152,6 +172,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NamedSetOfREAL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "namedSetOfREAL"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfEnums),
@@ -159,6 +181,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NamedSetOfEnums,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "namedSetOfEnums"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.seqOfZuka),
@@ -166,6 +190,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_SeqOfZuka,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "seqOfZuka"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfChoice),
@@ -173,6 +199,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_SetOfChoice,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "setOfChoice"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfChoice),
@@ -180,10 +208,12 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NamedSetOfChoice,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "namedSetOfChoice"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_PDU_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_PDU_tag2el_1[] = {
     { (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 }, /* sequenceOf at 21 */
@@ -200,14 +230,15 @@
     { (ASN_TAG_CLASS_CONTEXT | (13 << 2)), 13, 0, 0 }, /* setOfChoice at 32 */
     { (ASN_TAG_CLASS_CONTEXT | (14 << 2)), 14, 0, 0 } /* namedSetOfChoice at 33 */
 };
-static asn_CHOICE_specifics_t asn_SPC_PDU_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_PDU_specs_1 = {
 	sizeof(struct PDU),
 	offsetof(struct PDU, _asn_ctx),
 	offsetof(struct PDU, present),
 	sizeof(((struct PDU *)0)->present),
-	asn_MAP_PDU_1_tag2el,
+	asn_MAP_PDU_tag2el_1,
 	15,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 15	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_PDU = {
 	"PDU",
@@ -219,14 +250,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_PDU_1,
 	15,	/* Elements count */
-	&asn_SPC_PDU_1_specs	/* Additional specs */
+	&asn_SPC_PDU_specs_1	/* Additional specs */
 };
 
 
@@ -269,6 +302,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "integer"
 		},
 	{ ATF_POINTER, 2, offsetof(struct Sequence, sequence),
@@ -276,6 +311,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "sequence"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Sequence, bits),
@@ -283,6 +320,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_BIT_STRING,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "bits"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Sequence, string),
@@ -290,23 +329,26 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_UTF8String,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "string"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Sequence_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Sequence_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* integer at 38 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* sequence at 39 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* bits at 40 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* string at 41 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Sequence_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
 	sizeof(struct Sequence),
 	offsetof(struct Sequence, _asn_ctx),
-	asn_MAP_Sequence_1_tag2el,
+	asn_MAP_Sequence_tag2el_1,
 	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -320,16 +362,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Sequence_tags_1,
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	asn_DEF_Sequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Sequence_1,
 	4,	/* Elements count */
-	&asn_SPC_Sequence_1_specs	/* Additional specs */
+	&asn_SPC_Sequence_specs_1	/* Additional specs */
 };
 
 
@@ -376,6 +420,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_RELATIVE_OID,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "roid"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Set, opaque),
@@ -383,29 +429,31 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_OCTET_STRING,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "opaque"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Set_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Set_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Set_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Set_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* roid at 45 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* opaque at 46 */
 };
-static uint8_t asn_MAP_Set_1_mmap[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Set_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (0 << 6)
 };
-static asn_SET_specifics_t asn_SPC_Set_1_specs = {
+static asn_SET_specifics_t asn_SPC_Set_specs_1 = {
 	sizeof(struct Set),
 	offsetof(struct Set, _asn_ctx),
 	offsetof(struct Set, _presence_map),
-	asn_MAP_Set_1_tag2el,
+	asn_MAP_Set_tag2el_1,
 	2,	/* Count of tags in the map */
-	asn_MAP_Set_1_tag2el,	/* Same as above */
+	asn_MAP_Set_tag2el_1,	/* Same as above */
 	2,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_Set_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Set_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Set = {
 	"Set",
@@ -417,16 +465,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Set_tags_1,
+	sizeof(asn_DEF_Set_tags_1)
+		/sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
+	asn_DEF_Set_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Set_tags_1)
+		/sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Set_1,
 	2,	/* Elements count */
-	&asn_SPC_Set_1_specs	/* Additional specs */
+	&asn_SPC_Set_specs_1	/* Additional specs */
 };
 
 
@@ -496,6 +546,9 @@
 	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
 	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
 	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
 	td->elements       = asn_DEF_ENUMERATED.elements;
 	td->elements_count = asn_DEF_ENUMERATED.elements_count;
      /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
@@ -548,22 +601,22 @@
 
 /*** <<< STAT-DEFS [ExtensibleSet] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_enum_4_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_enum_value2enum_4[] = {
 	{ 0,	1,	"b" },
 	{ 1,	1,	"a" }
 };
-static unsigned int asn_MAP_enum_4_enum2value[] = {
+static unsigned int asn_MAP_enum_enum2value_4[] = {
 	1,	/* a(1) */
 	0	/* b(0) */
 };
-static asn_INTEGER_specifics_t asn_SPC_enum_4_specs = {
-	asn_MAP_enum_4_value2enum,	/* "tag" => N; sorted by tag */
-	asn_MAP_enum_4_enum2value,	/* N => "tag"; sorted by N */
+static asn_INTEGER_specifics_t asn_SPC_enum_specs_4 = {
+	asn_MAP_enum_value2enum_4,	/* "tag" => N; sorted by tag */
+	asn_MAP_enum_enum2value_4,	/* 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_enum_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_enum_tags_4[] = {
 	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
@@ -578,15 +631,17 @@
 	enum_4_encode_der,
 	enum_4_decode_xer,
 	enum_4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_enum_4_tags,
-	sizeof(asn_DEF_enum_4_tags)
-		/sizeof(asn_DEF_enum_4_tags[0]) - 1, /* 1 */
-	asn_DEF_enum_4_tags,	/* Same as above */
-	sizeof(asn_DEF_enum_4_tags)
-		/sizeof(asn_DEF_enum_4_tags[0]), /* 2 */
+	asn_DEF_enum_tags_4,
+	sizeof(asn_DEF_enum_tags_4)
+		/sizeof(asn_DEF_enum_tags_4[0]) - 1, /* 1 */
+	asn_DEF_enum_tags_4,	/* Same as above */
+	sizeof(asn_DEF_enum_tags_4)
+		/sizeof(asn_DEF_enum_tags_4[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
-	&asn_SPC_enum_4_specs	/* Additional specs */
+	&asn_SPC_enum_specs_4	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_ExtensibleSet_1[] = {
@@ -595,6 +650,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_UTF8String,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "string"
 		},
 	{ ATF_POINTER, 1, offsetof(struct ExtensibleSet, Enum),
@@ -602,29 +659,31 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_enum_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "enum"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ExtensibleSet_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_ExtensibleSet_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_ExtensibleSet_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ExtensibleSet_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string at 50 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* enum at 52 */
 };
-static uint8_t asn_MAP_ExtensibleSet_1_mmap[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_ExtensibleSet_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(0 << 7) | (0 << 6)
 };
-static asn_SET_specifics_t asn_SPC_ExtensibleSet_1_specs = {
+static asn_SET_specifics_t asn_SPC_ExtensibleSet_specs_1 = {
 	sizeof(struct ExtensibleSet),
 	offsetof(struct ExtensibleSet, _asn_ctx),
 	offsetof(struct ExtensibleSet, _presence_map),
-	asn_MAP_ExtensibleSet_1_tag2el,
+	asn_MAP_ExtensibleSet_tag2el_1,
 	2,	/* Count of tags in the map */
-	asn_MAP_ExtensibleSet_1_tag2el,	/* Same as above */
+	asn_MAP_ExtensibleSet_tag2el_1,	/* Same as above */
 	2,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_MAP_ExtensibleSet_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_ExtensibleSet_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_ExtensibleSet = {
 	"ExtensibleSet",
@@ -636,16 +695,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_ExtensibleSet_tags_1,
+	sizeof(asn_DEF_ExtensibleSet_tags_1)
+		/sizeof(asn_DEF_ExtensibleSet_tags_1[0]), /* 1 */
+	asn_DEF_ExtensibleSet_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ExtensibleSet_tags_1)
+		/sizeof(asn_DEF_ExtensibleSet_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_ExtensibleSet_1,
 	2,	/* Elements count */
-	&asn_SPC_ExtensibleSet_1_specs	/* Additional specs */
+	&asn_SPC_ExtensibleSet_specs_1	/* Additional specs */
 };
 
 
@@ -683,6 +744,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_UTF8String,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "string"
 		},
 	{ ATF_POINTER, 2, offsetof(struct ExtensibleSequence, integer),
@@ -690,6 +753,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "integer"
 		},
 	{ ATF_POINTER, 1, offsetof(struct ExtensibleSequence, gtime),
@@ -697,22 +762,25 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_GeneralizedTime,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "gtime"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ExtensibleSequence_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_ExtensibleSequence_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string at 56 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* integer at 58 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* gtime at 59 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_specs_1 = {
 	sizeof(struct ExtensibleSequence),
 	offsetof(struct ExtensibleSequence, _asn_ctx),
-	asn_MAP_ExtensibleSequence_1_tag2el,
+	asn_MAP_ExtensibleSequence_tag2el_1,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	0,	/* Start extensions */
 	4	/* Stop extensions */
 };
@@ -726,16 +794,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_ExtensibleSequence_tags_1,
+	sizeof(asn_DEF_ExtensibleSequence_tags_1)
+		/sizeof(asn_DEF_ExtensibleSequence_tags_1[0]), /* 1 */
+	asn_DEF_ExtensibleSequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ExtensibleSequence_tags_1)
+		/sizeof(asn_DEF_ExtensibleSequence_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_ExtensibleSequence_1,
 	3,	/* Elements count */
-	&asn_SPC_ExtensibleSequence_1_specs	/* Additional specs */
+	&asn_SPC_ExtensibleSequence_specs_1	/* Additional specs */
 };
 
 
@@ -771,6 +841,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_UTF8String,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "string"
 		},
 	{ ATF_POINTER, 1, offsetof(struct ExtensibleSequence2, integer),
@@ -778,21 +850,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "integer"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ExtensibleSequence2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_ExtensibleSequence2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence2_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence2_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string at 63 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* integer at 65 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence2_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence2_specs_1 = {
 	sizeof(struct ExtensibleSequence2),
 	offsetof(struct ExtensibleSequence2, _asn_ctx),
-	asn_MAP_ExtensibleSequence2_1_tag2el,
+	asn_MAP_ExtensibleSequence2_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	0,	/* Start extensions */
 	3	/* Stop extensions */
 };
@@ -806,16 +881,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ExtensibleSequence2_1_tags,
-	sizeof(asn_DEF_ExtensibleSequence2_1_tags)
-		/sizeof(asn_DEF_ExtensibleSequence2_1_tags[0]), /* 1 */
-	asn_DEF_ExtensibleSequence2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_ExtensibleSequence2_1_tags)
-		/sizeof(asn_DEF_ExtensibleSequence2_1_tags[0]), /* 1 */
+	asn_DEF_ExtensibleSequence2_tags_1,
+	sizeof(asn_DEF_ExtensibleSequence2_tags_1)
+		/sizeof(asn_DEF_ExtensibleSequence2_tags_1[0]), /* 1 */
+	asn_DEF_ExtensibleSequence2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ExtensibleSequence2_tags_1)
+		/sizeof(asn_DEF_ExtensibleSequence2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_ExtensibleSequence2_1,
 	2,	/* Elements count */
-	&asn_SPC_ExtensibleSequence2_1_specs	/* Additional specs */
+	&asn_SPC_ExtensibleSequence2_specs_1	/* Additional specs */
 };
 
 
@@ -846,13 +923,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_SetOfNULL_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SetOfNULL_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_SetOfNULL_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SetOfNULL_specs_1 = {
 	sizeof(struct SetOfNULL),
 	offsetof(struct SetOfNULL, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -867,16 +946,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_SetOfNULL_tags_1,
+	sizeof(asn_DEF_SetOfNULL_tags_1)
+		/sizeof(asn_DEF_SetOfNULL_tags_1[0]), /* 1 */
+	asn_DEF_SetOfNULL_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SetOfNULL_tags_1)
+		/sizeof(asn_DEF_SetOfNULL_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_SetOfNULL_1,
 	1,	/* Single element */
-	&asn_SPC_SetOfNULL_1_specs	/* Additional specs */
+	&asn_SPC_SetOfNULL_specs_1	/* Additional specs */
 };
 
 
@@ -907,13 +988,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_REAL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_SetOfREAL_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SetOfREAL_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_SetOfREAL_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SetOfREAL_specs_1 = {
 	sizeof(struct SetOfREAL),
 	offsetof(struct SetOfREAL, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -928,16 +1011,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SetOfREAL_1_tags,
-	sizeof(asn_DEF_SetOfREAL_1_tags)
-		/sizeof(asn_DEF_SetOfREAL_1_tags[0]), /* 1 */
-	asn_DEF_SetOfREAL_1_tags,	/* Same as above */
-	sizeof(asn_DEF_SetOfREAL_1_tags)
-		/sizeof(asn_DEF_SetOfREAL_1_tags[0]), /* 1 */
+	asn_DEF_SetOfREAL_tags_1,
+	sizeof(asn_DEF_SetOfREAL_tags_1)
+		/sizeof(asn_DEF_SetOfREAL_tags_1[0]), /* 1 */
+	asn_DEF_SetOfREAL_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SetOfREAL_tags_1)
+		/sizeof(asn_DEF_SetOfREAL_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_SetOfREAL_1,
 	1,	/* Single element */
-	&asn_SPC_SetOfREAL_1_specs	/* Additional specs */
+	&asn_SPC_SetOfREAL_specs_1	/* Additional specs */
 };
 
 
@@ -990,6 +1075,9 @@
 	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
 	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
 	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
 	td->elements       = asn_DEF_ENUMERATED.elements;
 	td->elements_count = asn_DEF_ENUMERATED.elements_count;
      /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
@@ -1042,28 +1130,28 @@
 
 /*** <<< STAT-DEFS [SetOfEnums] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_Member_2_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_Member_value2enum_2[] = {
 	{ 0,	3,	"one" },
 	{ 1,	7,	"oneMore" }
 };
-static unsigned int asn_MAP_Member_2_enum2value[] = {
+static unsigned int asn_MAP_Member_enum2value_2[] = {
 	0,	/* one(0) */
 	1	/* oneMore(1) */
 };
-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 */
+static asn_INTEGER_specifics_t asn_SPC_Member_specs_2 = {
+	asn_MAP_Member_value2enum_2,	/* "tag" => N; sorted by tag */
+	asn_MAP_Member_enum2value_2,	/* 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_Member_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_Member_2 = {
-	"",
-	"",
+	"ENUMERATED",
+	"ENUMERATED",
 	Member_2_free,
 	Member_2_print,
 	Member_2_constraint,
@@ -1071,15 +1159,17 @@
 	Member_2_encode_der,
 	Member_2_decode_xer,
 	Member_2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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 */
+	asn_DEF_Member_tags_2,
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	asn_DEF_Member_tags_2,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
-	&asn_SPC_Member_2_specs	/* Additional specs */
+	&asn_SPC_Member_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_SetOfEnums_1[] = {
@@ -1088,13 +1178,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Member_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_SetOfEnums_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SetOfEnums_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_SetOfEnums_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SetOfEnums_specs_1 = {
 	sizeof(struct SetOfEnums),
 	offsetof(struct SetOfEnums, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -1109,16 +1201,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_SetOfEnums_tags_1,
+	sizeof(asn_DEF_SetOfEnums_tags_1)
+		/sizeof(asn_DEF_SetOfEnums_tags_1[0]), /* 1 */
+	asn_DEF_SetOfEnums_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SetOfEnums_tags_1)
+		/sizeof(asn_DEF_SetOfEnums_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_SetOfEnums_1,
 	1,	/* Single element */
-	&asn_SPC_SetOfEnums_1_specs	/* Additional specs */
+	&asn_SPC_SetOfEnums_specs_1	/* Additional specs */
 };
 
 
@@ -1149,13 +1243,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "y"
 		},
 };
-static ber_tlv_tag_t asn_DEF_NamedSetOfNULL_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NamedSetOfNULL_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_NamedSetOfNULL_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_NamedSetOfNULL_specs_1 = {
 	sizeof(struct NamedSetOfNULL),
 	offsetof(struct NamedSetOfNULL, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -1170,16 +1266,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NamedSetOfNULL_1_tags,
-	sizeof(asn_DEF_NamedSetOfNULL_1_tags)
-		/sizeof(asn_DEF_NamedSetOfNULL_1_tags[0]), /* 1 */
-	asn_DEF_NamedSetOfNULL_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NamedSetOfNULL_1_tags)
-		/sizeof(asn_DEF_NamedSetOfNULL_1_tags[0]), /* 1 */
+	asn_DEF_NamedSetOfNULL_tags_1,
+	sizeof(asn_DEF_NamedSetOfNULL_tags_1)
+		/sizeof(asn_DEF_NamedSetOfNULL_tags_1[0]), /* 1 */
+	asn_DEF_NamedSetOfNULL_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NamedSetOfNULL_tags_1)
+		/sizeof(asn_DEF_NamedSetOfNULL_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_NamedSetOfNULL_1,
 	1,	/* Single element */
-	&asn_SPC_NamedSetOfNULL_1_specs	/* Additional specs */
+	&asn_SPC_NamedSetOfNULL_specs_1	/* Additional specs */
 };
 
 
@@ -1210,13 +1308,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_REAL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "name"
 		},
 };
-static ber_tlv_tag_t asn_DEF_NamedSetOfREAL_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NamedSetOfREAL_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_NamedSetOfREAL_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_NamedSetOfREAL_specs_1 = {
 	sizeof(struct NamedSetOfREAL),
 	offsetof(struct NamedSetOfREAL, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -1231,16 +1331,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NamedSetOfREAL_1_tags,
-	sizeof(asn_DEF_NamedSetOfREAL_1_tags)
-		/sizeof(asn_DEF_NamedSetOfREAL_1_tags[0]), /* 1 */
-	asn_DEF_NamedSetOfREAL_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NamedSetOfREAL_1_tags)
-		/sizeof(asn_DEF_NamedSetOfREAL_1_tags[0]), /* 1 */
+	asn_DEF_NamedSetOfREAL_tags_1,
+	sizeof(asn_DEF_NamedSetOfREAL_tags_1)
+		/sizeof(asn_DEF_NamedSetOfREAL_tags_1[0]), /* 1 */
+	asn_DEF_NamedSetOfREAL_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NamedSetOfREAL_tags_1)
+		/sizeof(asn_DEF_NamedSetOfREAL_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_NamedSetOfREAL_1,
 	1,	/* Single element */
-	&asn_SPC_NamedSetOfREAL_1_specs	/* Additional specs */
+	&asn_SPC_NamedSetOfREAL_specs_1	/* Additional specs */
 };
 
 
@@ -1293,6 +1395,9 @@
 	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
 	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
 	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
 	td->elements       = asn_DEF_ENUMERATED.elements;
 	td->elements_count = asn_DEF_ENUMERATED.elements_count;
      /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
@@ -1345,28 +1450,28 @@
 
 /*** <<< STAT-DEFS [NamedSetOfEnums] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_name_2_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_name_value2enum_2[] = {
 	{ 0,	3,	"one" },
 	{ 1,	7,	"oneMore" }
 };
-static unsigned int asn_MAP_name_2_enum2value[] = {
+static unsigned int asn_MAP_name_enum2value_2[] = {
 	0,	/* one(0) */
 	1	/* oneMore(1) */
 };
-static asn_INTEGER_specifics_t asn_SPC_name_2_specs = {
-	asn_MAP_name_2_value2enum,	/* "tag" => N; sorted by tag */
-	asn_MAP_name_2_enum2value,	/* N => "tag"; sorted by N */
+static asn_INTEGER_specifics_t asn_SPC_name_specs_2 = {
+	asn_MAP_name_value2enum_2,	/* "tag" => N; sorted by tag */
+	asn_MAP_name_enum2value_2,	/* 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_name_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_name_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_name_2 = {
-	"",
-	"",
+	"ENUMERATED",
+	"ENUMERATED",
 	name_2_free,
 	name_2_print,
 	name_2_constraint,
@@ -1374,15 +1479,17 @@
 	name_2_encode_der,
 	name_2_decode_xer,
 	name_2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_name_2_tags,
-	sizeof(asn_DEF_name_2_tags)
-		/sizeof(asn_DEF_name_2_tags[0]), /* 1 */
-	asn_DEF_name_2_tags,	/* Same as above */
-	sizeof(asn_DEF_name_2_tags)
-		/sizeof(asn_DEF_name_2_tags[0]), /* 1 */
+	asn_DEF_name_tags_2,
+	sizeof(asn_DEF_name_tags_2)
+		/sizeof(asn_DEF_name_tags_2[0]), /* 1 */
+	asn_DEF_name_tags_2,	/* Same as above */
+	sizeof(asn_DEF_name_tags_2)
+		/sizeof(asn_DEF_name_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
-	&asn_SPC_name_2_specs	/* Additional specs */
+	&asn_SPC_name_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_NamedSetOfEnums_1[] = {
@@ -1391,13 +1498,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_name_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "name"
 		},
 };
-static ber_tlv_tag_t asn_DEF_NamedSetOfEnums_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NamedSetOfEnums_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_NamedSetOfEnums_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_NamedSetOfEnums_specs_1 = {
 	sizeof(struct NamedSetOfEnums),
 	offsetof(struct NamedSetOfEnums, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -1412,16 +1521,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NamedSetOfEnums_1_tags,
-	sizeof(asn_DEF_NamedSetOfEnums_1_tags)
-		/sizeof(asn_DEF_NamedSetOfEnums_1_tags[0]), /* 1 */
-	asn_DEF_NamedSetOfEnums_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NamedSetOfEnums_1_tags)
-		/sizeof(asn_DEF_NamedSetOfEnums_1_tags[0]), /* 1 */
+	asn_DEF_NamedSetOfEnums_tags_1,
+	sizeof(asn_DEF_NamedSetOfEnums_tags_1)
+		/sizeof(asn_DEF_NamedSetOfEnums_tags_1[0]), /* 1 */
+	asn_DEF_NamedSetOfEnums_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NamedSetOfEnums_tags_1)
+		/sizeof(asn_DEF_NamedSetOfEnums_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_NamedSetOfEnums_1,
 	1,	/* Single element */
-	&asn_SPC_NamedSetOfEnums_1_specs	/* Additional specs */
+	&asn_SPC_NamedSetOfEnums_specs_1	/* Additional specs */
 };
 
 
@@ -1452,13 +1563,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "id"
 		},
 };
-static ber_tlv_tag_t asn_DEF_SequenceOf_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SequenceOf_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_SequenceOf_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SequenceOf_specs_1 = {
 	sizeof(struct SequenceOf),
 	offsetof(struct SequenceOf, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -1473,16 +1586,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_SequenceOf_tags_1,
+	sizeof(asn_DEF_SequenceOf_tags_1)
+		/sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */
+	asn_DEF_SequenceOf_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SequenceOf_tags_1)
+		/sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_SequenceOf_1,
 	1,	/* Single element */
-	&asn_SPC_SequenceOf_1_specs	/* Additional specs */
+	&asn_SPC_SequenceOf_specs_1	/* Additional specs */
 };
 
 
@@ -1513,13 +1628,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "zuka"
 		},
 };
-static ber_tlv_tag_t asn_DEF_SeqOfZuka_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SeqOfZuka_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_SeqOfZuka_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SeqOfZuka_specs_1 = {
 	sizeof(struct SeqOfZuka),
 	offsetof(struct SeqOfZuka, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -1534,16 +1651,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_SeqOfZuka_tags_1,
+	sizeof(asn_DEF_SeqOfZuka_tags_1)
+		/sizeof(asn_DEF_SeqOfZuka_tags_1[0]), /* 1 */
+	asn_DEF_SeqOfZuka_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SeqOfZuka_tags_1)
+		/sizeof(asn_DEF_SeqOfZuka_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_SeqOfZuka_1,
 	1,	/* Single element */
-	&asn_SPC_SeqOfZuka_1_specs	/* Additional specs */
+	&asn_SPC_SeqOfZuka_specs_1	/* Additional specs */
 };
 
 
@@ -1581,13 +1700,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_SimpleChoice,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_SetOfChoice_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_SetOfChoice_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_SetOfChoice_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_SetOfChoice_specs_1 = {
 	sizeof(struct SetOfChoice),
 	offsetof(struct SetOfChoice, _asn_ctx),
 	2,	/* XER encoding is XMLValueList */
@@ -1602,16 +1723,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_SetOfChoice_1_tags,
-	sizeof(asn_DEF_SetOfChoice_1_tags)
-		/sizeof(asn_DEF_SetOfChoice_1_tags[0]), /* 1 */
-	asn_DEF_SetOfChoice_1_tags,	/* Same as above */
-	sizeof(asn_DEF_SetOfChoice_1_tags)
-		/sizeof(asn_DEF_SetOfChoice_1_tags[0]), /* 1 */
+	asn_DEF_SetOfChoice_tags_1,
+	sizeof(asn_DEF_SetOfChoice_tags_1)
+		/sizeof(asn_DEF_SetOfChoice_tags_1[0]), /* 1 */
+	asn_DEF_SetOfChoice_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SetOfChoice_tags_1)
+		/sizeof(asn_DEF_SetOfChoice_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_SetOfChoice_1,
 	1,	/* Single element */
-	&asn_SPC_SetOfChoice_1_specs	/* Additional specs */
+	&asn_SPC_SetOfChoice_specs_1	/* Additional specs */
 };
 
 
@@ -1649,13 +1772,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_SimpleChoice,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "whatever"
 		},
 };
-static ber_tlv_tag_t asn_DEF_NamedSetOfChoice_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NamedSetOfChoice_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_NamedSetOfChoice_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_NamedSetOfChoice_specs_1 = {
 	sizeof(struct NamedSetOfChoice),
 	offsetof(struct NamedSetOfChoice, _asn_ctx),
 	2,	/* XER encoding is XMLValueList */
@@ -1670,16 +1795,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NamedSetOfChoice_1_tags,
-	sizeof(asn_DEF_NamedSetOfChoice_1_tags)
-		/sizeof(asn_DEF_NamedSetOfChoice_1_tags[0]), /* 1 */
-	asn_DEF_NamedSetOfChoice_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NamedSetOfChoice_1_tags)
-		/sizeof(asn_DEF_NamedSetOfChoice_1_tags[0]), /* 1 */
+	asn_DEF_NamedSetOfChoice_tags_1,
+	sizeof(asn_DEF_NamedSetOfChoice_tags_1)
+		/sizeof(asn_DEF_NamedSetOfChoice_tags_1[0]), /* 1 */
+	asn_DEF_NamedSetOfChoice_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NamedSetOfChoice_tags_1)
+		/sizeof(asn_DEF_NamedSetOfChoice_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_NamedSetOfChoice_1,
 	1,	/* Single element */
-	&asn_SPC_NamedSetOfChoice_1_specs	/* Additional specs */
+	&asn_SPC_NamedSetOfChoice_specs_1	/* Additional specs */
 };
 
 
@@ -1722,6 +1849,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NULL,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct SimpleChoice, choice.b),
@@ -1729,21 +1858,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_SimpleChoice_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_SimpleChoice_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 79 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b at 79 */
 };
-static asn_CHOICE_specifics_t asn_SPC_SimpleChoice_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_SimpleChoice_specs_1 = {
 	sizeof(struct SimpleChoice),
 	offsetof(struct SimpleChoice, _asn_ctx),
 	offsetof(struct SimpleChoice, present),
 	sizeof(((struct SimpleChoice *)0)->present),
-	asn_MAP_SimpleChoice_1_tag2el,
+	asn_MAP_SimpleChoice_tag2el_1,
 	2,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_SimpleChoice = {
 	"SimpleChoice",
@@ -1755,13 +1887,15 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_SimpleChoice_1,
 	2,	/* Elements count */
-	&asn_SPC_SimpleChoice_1_specs	/* Additional specs */
+	&asn_SPC_SimpleChoice_specs_1	/* Additional specs */
 };
 
diff --git a/tests/72-same-names-OK.asn1.-P b/tests/72-same-names-OK.asn1.-P
index b183aeb..e4d210c 100644
--- a/tests/72-same-names-OK.asn1.-P
+++ b/tests/72-same-names-OK.asn1.-P
@@ -34,6 +34,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Type1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "t1"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Member, t2),
@@ -41,29 +43,32 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Type2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "t2"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Member_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Member_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Member_tag2el_2[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* t1 at 21 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 }, /* one-name at 37 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 1, 0, 0 } /* two-name at 43 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Member_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Member_specs_2 = {
 	sizeof(struct Member),
 	offsetof(struct Member, _asn_ctx),
-	asn_MAP_Member_2_tag2el,
+	asn_MAP_Member_tag2el_2,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_Member_2 = {
-	"",
-	"",
+	"SEQUENCE",
+	"SEQUENCE",
 	SEQUENCE_free,
 	SEQUENCE_print,
 	SEQUENCE_constraint,
@@ -71,16 +76,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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 */
+	asn_DEF_Member_tags_2,
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	asn_DEF_Member_tags_2,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Member_2,
 	2,	/* Elements count */
-	&asn_SPC_Member_2_specs	/* Additional specs */
+	&asn_SPC_Member_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Type_1[] = {
@@ -89,13 +96,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Member_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Type_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Type_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_Type_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Type_specs_1 = {
 	sizeof(struct Type),
 	offsetof(struct Type, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -110,16 +119,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Type_1_tags,
-	sizeof(asn_DEF_Type_1_tags)
-		/sizeof(asn_DEF_Type_1_tags[0]), /* 1 */
-	asn_DEF_Type_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Type_1_tags)
-		/sizeof(asn_DEF_Type_1_tags[0]), /* 1 */
+	asn_DEF_Type_tags_1,
+	sizeof(asn_DEF_Type_tags_1)
+		/sizeof(asn_DEF_Type_tags_1[0]), /* 1 */
+	asn_DEF_Type_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Type_tags_1)
+		/sizeof(asn_DEF_Type_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Type_1,
 	1,	/* Single element */
-	&asn_SPC_Type_1_specs	/* Additional specs */
+	&asn_SPC_Type_specs_1	/* Additional specs */
 };
 
 
@@ -171,6 +182,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct another_name, b),
@@ -178,21 +191,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_another_name_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_another_name_tags_3[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_another_name_3_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_another_name_tag2el_3[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 1 }, /* a at 27 */
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, -1, 0 } /* b at 27 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_another_name_3_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_another_name_specs_3 = {
 	sizeof(struct another_name),
 	offsetof(struct another_name, _asn_ctx),
-	asn_MAP_another_name_3_tag2el,
+	asn_MAP_another_name_tag2el_3,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -207,16 +223,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_another_name_3_tags,
-	sizeof(asn_DEF_another_name_3_tags)
-		/sizeof(asn_DEF_another_name_3_tags[0]), /* 1 */
-	asn_DEF_another_name_3_tags,	/* Same as above */
-	sizeof(asn_DEF_another_name_3_tags)
-		/sizeof(asn_DEF_another_name_3_tags[0]), /* 1 */
+	asn_DEF_another_name_tags_3,
+	sizeof(asn_DEF_another_name_tags_3)
+		/sizeof(asn_DEF_another_name_tags_3[0]), /* 1 */
+	asn_DEF_another_name_tags_3,	/* Same as above */
+	sizeof(asn_DEF_another_name_tags_3)
+		/sizeof(asn_DEF_another_name_tags_3[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_another_name_3,
 	2,	/* Elements count */
-	&asn_SPC_another_name_3_specs	/* Additional specs */
+	&asn_SPC_another_name_specs_3	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_one_name_2[] = {
@@ -225,20 +243,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_another_name_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "another-name"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_one_name_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_one_name_tag2el_2[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* another-name at 27 */
 };
-static asn_CHOICE_specifics_t asn_SPC_one_name_2_specs = {
+static asn_CHOICE_specifics_t asn_SPC_one_name_specs_2 = {
 	sizeof(struct one_name),
 	offsetof(struct one_name, _asn_ctx),
 	offsetof(struct one_name, present),
 	sizeof(((struct one_name *)0)->present),
-	asn_MAP_one_name_2_tag2el,
+	asn_MAP_one_name_tag2el_2,
 	1,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_one_name_2 = {
@@ -251,14 +272,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_one_name_2,
 	1,	/* Elements count */
-	&asn_SPC_one_name_2_specs	/* Additional specs */
+	&asn_SPC_one_name_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Type1_1[] = {
@@ -267,20 +290,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_one_name_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "one-name"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Type1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Type1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Type1_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Type1_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* another-name at 27 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Type1_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Type1_specs_1 = {
 	sizeof(struct Type1),
 	offsetof(struct Type1, _asn_ctx),
-	asn_MAP_Type1_1_tag2el,
+	asn_MAP_Type1_tag2el_1,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -294,16 +320,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Type1_1_tags,
-	sizeof(asn_DEF_Type1_1_tags)
-		/sizeof(asn_DEF_Type1_1_tags[0]), /* 1 */
-	asn_DEF_Type1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Type1_1_tags)
-		/sizeof(asn_DEF_Type1_1_tags[0]), /* 1 */
+	asn_DEF_Type1_tags_1,
+	sizeof(asn_DEF_Type1_tags_1)
+		/sizeof(asn_DEF_Type1_tags_1[0]), /* 1 */
+	asn_DEF_Type1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Type1_tags_1)
+		/sizeof(asn_DEF_Type1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Type1_1,
 	1,	/* Elements count */
-	&asn_SPC_Type1_1_specs	/* Additional specs */
+	&asn_SPC_Type1_specs_1	/* Additional specs */
 };
 
 
@@ -382,7 +410,7 @@
 /*** <<< CODE [Type2] >>> ***/
 
 static int
-memb_a_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_a_constraint_3(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 	size_t size;
@@ -413,7 +441,7 @@
 }
 
 static int
-memb_a_8_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_a_constraint_8(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 	size_t size;
@@ -451,7 +479,9 @@
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_BIT_STRING,
-		.memb_constraints = memb_a_3_constraint,
+		.memb_constraints = memb_a_constraint_3,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct another_name, b),
@@ -459,21 +489,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_another_name_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_another_name_tags_3[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_another_name_3_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_another_name_tag2el_3[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* b at 36 */
     { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 0, 0, 0 } /* a at 34 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_another_name_3_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_another_name_specs_3 = {
 	sizeof(struct another_name),
 	offsetof(struct another_name, _asn_ctx),
-	asn_MAP_another_name_3_tag2el,
+	asn_MAP_another_name_tag2el_3,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -488,16 +521,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_another_name_3_tags,
-	sizeof(asn_DEF_another_name_3_tags)
-		/sizeof(asn_DEF_another_name_3_tags[0]), /* 1 */
-	asn_DEF_another_name_3_tags,	/* Same as above */
-	sizeof(asn_DEF_another_name_3_tags)
-		/sizeof(asn_DEF_another_name_3_tags[0]), /* 1 */
+	asn_DEF_another_name_tags_3,
+	sizeof(asn_DEF_another_name_tags_3)
+		/sizeof(asn_DEF_another_name_tags_3[0]), /* 1 */
+	asn_DEF_another_name_tags_3,	/* Same as above */
+	sizeof(asn_DEF_another_name_tags_3)
+		/sizeof(asn_DEF_another_name_tags_3[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_another_name_3,
 	2,	/* Elements count */
-	&asn_SPC_another_name_3_specs	/* Additional specs */
+	&asn_SPC_another_name_specs_3	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_one_name_2[] = {
@@ -506,20 +541,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_another_name_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "another-name"
 		},
 };
-static ber_tlv_tag_t asn_DEF_one_name_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_one_name_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_one_name_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_one_name_tag2el_2[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* another-name at 34 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_one_name_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_one_name_specs_2 = {
 	sizeof(struct one_name),
 	offsetof(struct one_name, _asn_ctx),
-	asn_MAP_one_name_2_tag2el,
+	asn_MAP_one_name_tag2el_2,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -534,16 +572,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_one_name_2_tags,
-	sizeof(asn_DEF_one_name_2_tags)
-		/sizeof(asn_DEF_one_name_2_tags[0]), /* 1 */
-	asn_DEF_one_name_2_tags,	/* Same as above */
-	sizeof(asn_DEF_one_name_2_tags)
-		/sizeof(asn_DEF_one_name_2_tags[0]), /* 1 */
+	asn_DEF_one_name_tags_2,
+	sizeof(asn_DEF_one_name_tags_2)
+		/sizeof(asn_DEF_one_name_tags_2[0]), /* 1 */
+	asn_DEF_one_name_tags_2,	/* Same as above */
+	sizeof(asn_DEF_one_name_tags_2)
+		/sizeof(asn_DEF_one_name_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_one_name_2,
 	1,	/* Elements count */
-	&asn_SPC_one_name_2_specs	/* Additional specs */
+	&asn_SPC_one_name_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_another_name_8[] = {
@@ -551,7 +591,9 @@
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_BIT_STRING,
-		.memb_constraints = memb_a_8_constraint,
+		.memb_constraints = memb_a_constraint_8,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct another_name, b),
@@ -559,21 +601,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_another_name_8_tags[] = {
+static ber_tlv_tag_t asn_DEF_another_name_tags_8[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_another_name_8_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_another_name_tag2el_8[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* b at 42 */
     { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 0, 0, 0 } /* a at 40 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_another_name_8_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_another_name_specs_8 = {
 	sizeof(struct another_name),
 	offsetof(struct another_name, _asn_ctx),
-	asn_MAP_another_name_8_tag2el,
+	asn_MAP_another_name_tag2el_8,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -588,16 +633,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_another_name_8_tags,
-	sizeof(asn_DEF_another_name_8_tags)
-		/sizeof(asn_DEF_another_name_8_tags[0]), /* 1 */
-	asn_DEF_another_name_8_tags,	/* Same as above */
-	sizeof(asn_DEF_another_name_8_tags)
-		/sizeof(asn_DEF_another_name_8_tags[0]), /* 1 */
+	asn_DEF_another_name_tags_8,
+	sizeof(asn_DEF_another_name_tags_8)
+		/sizeof(asn_DEF_another_name_tags_8[0]), /* 1 */
+	asn_DEF_another_name_tags_8,	/* Same as above */
+	sizeof(asn_DEF_another_name_tags_8)
+		/sizeof(asn_DEF_another_name_tags_8[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_another_name_8,
 	2,	/* Elements count */
-	&asn_SPC_another_name_8_specs	/* Additional specs */
+	&asn_SPC_another_name_specs_8	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_two_name_7[] = {
@@ -606,28 +653,30 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_another_name_8,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "another-name"
 		},
 };
-static ber_tlv_tag_t asn_DEF_two_name_7_tags[] = {
+static ber_tlv_tag_t asn_DEF_two_name_tags_7[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_two_name_7_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_two_name_tag2el_7[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* another-name at 40 */
 };
-static uint8_t asn_MAP_two_name_7_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_two_name_mmap_7[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_SPC_two_name_7_specs = {
+static asn_SET_specifics_t asn_SPC_two_name_specs_7 = {
 	sizeof(struct two_name),
 	offsetof(struct two_name, _asn_ctx),
 	offsetof(struct two_name, _presence_map),
-	asn_MAP_two_name_7_tag2el,
+	asn_MAP_two_name_tag2el_7,
 	1,	/* Count of tags in the map */
-	asn_MAP_two_name_7_tag2el,	/* Same as above */
+	asn_MAP_two_name_tag2el_7,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_two_name_7_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_two_name_mmap_7	/* Mandatory elements map */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_two_name_7 = {
@@ -640,16 +689,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_two_name_7_tags,
-	sizeof(asn_DEF_two_name_7_tags)
-		/sizeof(asn_DEF_two_name_7_tags[0]), /* 1 */
-	asn_DEF_two_name_7_tags,	/* Same as above */
-	sizeof(asn_DEF_two_name_7_tags)
-		/sizeof(asn_DEF_two_name_7_tags[0]), /* 1 */
+	asn_DEF_two_name_tags_7,
+	sizeof(asn_DEF_two_name_tags_7)
+		/sizeof(asn_DEF_two_name_tags_7[0]), /* 1 */
+	asn_DEF_two_name_tags_7,	/* Same as above */
+	sizeof(asn_DEF_two_name_tags_7)
+		/sizeof(asn_DEF_two_name_tags_7[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_two_name_7,
 	1,	/* Elements count */
-	&asn_SPC_two_name_7_specs	/* Additional specs */
+	&asn_SPC_two_name_specs_7	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Type2_1[] = {
@@ -658,6 +709,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_one_name_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "one-name"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Type2, choice.two_name),
@@ -665,21 +718,24 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_two_name_7,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "two-name"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Type2_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Type2_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* one-name at 37 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 1, 0, 0 } /* two-name at 43 */
 };
-static asn_CHOICE_specifics_t asn_SPC_Type2_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Type2_specs_1 = {
 	sizeof(struct Type2),
 	offsetof(struct Type2, _asn_ctx),
 	offsetof(struct Type2, present),
 	sizeof(((struct Type2 *)0)->present),
-	asn_MAP_Type2_1_tag2el,
+	asn_MAP_Type2_tag2el_1,
 	2,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Type2 = {
 	"Type2",
@@ -691,13 +747,15 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Type2_1,
 	2,	/* Elements count */
-	&asn_SPC_Type2_1_specs	/* Additional specs */
+	&asn_SPC_Type2_specs_1	/* Additional specs */
 };
 
diff --git a/tests/73-circular-OK.asn1.-P b/tests/73-circular-OK.asn1.-P
index 596163d..4e29c9b 100644
--- a/tests/73-circular-OK.asn1.-P
+++ b/tests/73-circular-OK.asn1.-P
@@ -39,13 +39,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_EpytRef,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_data_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_data_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_data_2_specs = {
+static asn_SET_OF_specifics_t asn_SPC_data_specs_2 = {
 	sizeof(struct data),
 	offsetof(struct data, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -61,16 +63,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_data_2_tags,
-	sizeof(asn_DEF_data_2_tags)
-		/sizeof(asn_DEF_data_2_tags[0]), /* 1 */
-	asn_DEF_data_2_tags,	/* Same as above */
-	sizeof(asn_DEF_data_2_tags)
-		/sizeof(asn_DEF_data_2_tags[0]), /* 1 */
+	asn_DEF_data_tags_2,
+	sizeof(asn_DEF_data_tags_2)
+		/sizeof(asn_DEF_data_tags_2[0]), /* 1 */
+	asn_DEF_data_tags_2,	/* Same as above */
+	sizeof(asn_DEF_data_tags_2)
+		/sizeof(asn_DEF_data_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_data_2,
 	1,	/* Single element */
-	&asn_SPC_data_2_specs	/* Additional specs */
+	&asn_SPC_data_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Type_1[] = {
@@ -79,20 +83,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_data_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "data"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Type_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Type_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Type_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Type_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* data at 16 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Type_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Type_specs_1 = {
 	sizeof(struct Type),
 	offsetof(struct Type, _asn_ctx),
-	asn_MAP_Type_1_tag2el,
+	asn_MAP_Type_tag2el_1,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -106,16 +113,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Type_1_tags,
-	sizeof(asn_DEF_Type_1_tags)
-		/sizeof(asn_DEF_Type_1_tags[0]), /* 1 */
-	asn_DEF_Type_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Type_1_tags)
-		/sizeof(asn_DEF_Type_1_tags[0]), /* 1 */
+	asn_DEF_Type_tags_1,
+	sizeof(asn_DEF_Type_tags_1)
+		/sizeof(asn_DEF_Type_tags_1[0]), /* 1 */
+	asn_DEF_Type_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Type_tags_1)
+		/sizeof(asn_DEF_Type_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Type_1,
 	1,	/* Elements count */
-	&asn_SPC_Type_1_specs	/* Additional specs */
+	&asn_SPC_Type_specs_1	/* Additional specs */
 };
 
 
@@ -160,6 +169,9 @@
 	td->der_encoder    = asn_DEF_Epyt.der_encoder;
 	td->xer_decoder    = asn_DEF_Epyt.xer_decoder;
 	td->xer_encoder    = asn_DEF_Epyt.xer_encoder;
+	td->uper_decoder   = asn_DEF_Epyt.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Epyt.per_constraints;
 	td->elements       = asn_DEF_Epyt.elements;
 	td->elements_count = asn_DEF_Epyt.elements_count;
 	td->specifics      = asn_DEF_Epyt.specifics;
@@ -212,7 +224,7 @@
 
 /*** <<< STAT-DEFS [EpytRef] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_EpytRef_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_EpytRef_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_EpytRef = {
@@ -225,13 +237,15 @@
 	EpytRef_encode_der,
 	EpytRef_decode_xer,
 	EpytRef_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_EpytRef_1_tags,
-	sizeof(asn_DEF_EpytRef_1_tags)
-		/sizeof(asn_DEF_EpytRef_1_tags[0]), /* 1 */
-	asn_DEF_EpytRef_1_tags,	/* Same as above */
-	sizeof(asn_DEF_EpytRef_1_tags)
-		/sizeof(asn_DEF_EpytRef_1_tags[0]), /* 1 */
+	asn_DEF_EpytRef_tags_1,
+	sizeof(asn_DEF_EpytRef_tags_1)
+		/sizeof(asn_DEF_EpytRef_tags_1[0]), /* 1 */
+	asn_DEF_EpytRef_tags_1,	/* Same as above */
+	sizeof(asn_DEF_EpytRef_tags_1)
+		/sizeof(asn_DEF_EpytRef_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -281,13 +295,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Type,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_stype_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_stype_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_stype_2_specs = {
+static asn_SET_OF_specifics_t asn_SPC_stype_specs_2 = {
 	sizeof(struct stype),
 	offsetof(struct stype, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -303,16 +319,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_stype_2_tags,
-	sizeof(asn_DEF_stype_2_tags)
-		/sizeof(asn_DEF_stype_2_tags[0]), /* 1 */
-	asn_DEF_stype_2_tags,	/* Same as above */
-	sizeof(asn_DEF_stype_2_tags)
-		/sizeof(asn_DEF_stype_2_tags[0]), /* 1 */
+	asn_DEF_stype_tags_2,
+	sizeof(asn_DEF_stype_tags_2)
+		/sizeof(asn_DEF_stype_tags_2[0]), /* 1 */
+	asn_DEF_stype_tags_2,	/* Same as above */
+	sizeof(asn_DEF_stype_tags_2)
+		/sizeof(asn_DEF_stype_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_stype_2,
 	1,	/* Single element */
-	&asn_SPC_stype_2_specs	/* Additional specs */
+	&asn_SPC_stype_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Epyt_1[] = {
@@ -321,6 +339,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_stype_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "stype"
 		},
 	{ ATF_POINTER, 2, offsetof(struct Epyt, type),
@@ -328,6 +348,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Type,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "type"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Epyt, ypet),
@@ -335,22 +357,25 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Ypet,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ypet"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Epyt_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Epyt_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Epyt_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Epyt_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* type at 22 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 1 }, /* stype at 21 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 2, -1, 0 } /* ypet at 23 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Epyt_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Epyt_specs_1 = {
 	sizeof(struct Epyt),
 	offsetof(struct Epyt, _asn_ctx),
-	asn_MAP_Epyt_1_tag2el,
+	asn_MAP_Epyt_tag2el_1,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -364,16 +389,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Epyt_1_tags,
-	sizeof(asn_DEF_Epyt_1_tags)
-		/sizeof(asn_DEF_Epyt_1_tags[0]), /* 1 */
-	asn_DEF_Epyt_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Epyt_1_tags)
-		/sizeof(asn_DEF_Epyt_1_tags[0]), /* 1 */
+	asn_DEF_Epyt_tags_1,
+	sizeof(asn_DEF_Epyt_tags_1)
+		/sizeof(asn_DEF_Epyt_tags_1[0]), /* 1 */
+	asn_DEF_Epyt_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Epyt_tags_1)
+		/sizeof(asn_DEF_Epyt_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Epyt_1,
 	3,	/* Elements count */
-	&asn_SPC_Epyt_1_specs	/* Additional specs */
+	&asn_SPC_Epyt_specs_1	/* Additional specs */
 };
 
 
@@ -466,7 +493,7 @@
 /*** <<< CODE [Ypet] >>> ***/
 
 static int
-memb_patest1_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_patest1_constraint_1(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;
 	
@@ -490,7 +517,7 @@
 }
 
 static int
-memb_patest2_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_patest2_constraint_1(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;
 	
@@ -516,19 +543,32 @@
 
 /*** <<< STAT-DEFS [Ypet] >>> ***/
 
+static int asn_DFL_3_set_7(void **sptr) {
+	INTEGER_t *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 7 */
+	return asn_long2INTEGER(st, 7);
+}
 static asn_TYPE_member_t asn_MBR_senums_4[] = {
 	{ ATF_POINTER, 0, 0,
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_EnumType,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_senums_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_senums_tags_4[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_senums_4_specs = {
+static asn_SET_OF_specifics_t asn_SPC_senums_specs_4 = {
 	sizeof(struct senums),
 	offsetof(struct senums, _asn_ctx),
 	1,	/* XER encoding is XMLValueList */
@@ -544,16 +584,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_senums_4_tags,
-	sizeof(asn_DEF_senums_4_tags)
-		/sizeof(asn_DEF_senums_4_tags[0]), /* 1 */
-	asn_DEF_senums_4_tags,	/* Same as above */
-	sizeof(asn_DEF_senums_4_tags)
-		/sizeof(asn_DEF_senums_4_tags[0]), /* 1 */
+	asn_DEF_senums_tags_4,
+	sizeof(asn_DEF_senums_tags_4)
+		/sizeof(asn_DEF_senums_tags_4[0]), /* 1 */
+	asn_DEF_senums_tags_4,	/* Same as above */
+	sizeof(asn_DEF_senums_tags_4)
+		/sizeof(asn_DEF_senums_tags_4[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_senums_4,
 	1,	/* Single element */
-	&asn_SPC_senums_4_specs	/* Additional specs */
+	&asn_SPC_senums_specs_4	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Ypet_1[] = {
@@ -562,6 +604,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Epyt,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "epyt"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Ypet, plain),
@@ -569,6 +613,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = asn_DFL_3_set_7,	/* DEFAULT 7 */
 		.name = "plain"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Ypet, senums),
@@ -576,46 +622,52 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_senums_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "senums"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Ypet, patest1),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_IA5String,
-		.memb_constraints = memb_patest1_1_constraint,
+		.memb_constraints = memb_patest1_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "patest1"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Ypet, patest2),
 		.tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_IA5String,
-		.memb_constraints = memb_patest2_1_constraint,
+		.memb_constraints = memb_patest2_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "patest2"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Ypet_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Ypet_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Ypet_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Ypet_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* plain at 28 */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* epyt at 27 */
     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 2, 0, 0 }, /* senums at 29 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 3, 0, 0 }, /* patest1 at 30 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 4, 0, 0 } /* patest2 at 31 */
 };
-static uint8_t asn_MAP_Ypet_1_mmap[(5 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Ypet_mmap_1[(5 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (0 << 6) | (1 << 5) | (1 << 4) | (1 << 3)
 };
-static asn_SET_specifics_t asn_SPC_Ypet_1_specs = {
+static asn_SET_specifics_t asn_SPC_Ypet_specs_1 = {
 	sizeof(struct Ypet),
 	offsetof(struct Ypet, _asn_ctx),
 	offsetof(struct Ypet, _presence_map),
-	asn_MAP_Ypet_1_tag2el,
+	asn_MAP_Ypet_tag2el_1,
 	5,	/* Count of tags in the map */
-	asn_MAP_Ypet_1_tag2el,	/* Same as above */
+	asn_MAP_Ypet_tag2el_1,	/* Same as above */
 	5,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_Ypet_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Ypet_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Ypet = {
 	"Ypet",
@@ -627,16 +679,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Ypet_1_tags,
-	sizeof(asn_DEF_Ypet_1_tags)
-		/sizeof(asn_DEF_Ypet_1_tags[0]), /* 1 */
-	asn_DEF_Ypet_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Ypet_1_tags)
-		/sizeof(asn_DEF_Ypet_1_tags[0]), /* 1 */
+	asn_DEF_Ypet_tags_1,
+	sizeof(asn_DEF_Ypet_tags_1)
+		/sizeof(asn_DEF_Ypet_tags_1[0]), /* 1 */
+	asn_DEF_Ypet_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Ypet_tags_1)
+		/sizeof(asn_DEF_Ypet_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Ypet_1,
 	5,	/* Elements count */
-	&asn_SPC_Ypet_1_specs	/* Additional specs */
+	&asn_SPC_Ypet_specs_1	/* Additional specs */
 };
 
 
@@ -688,6 +742,9 @@
 	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
 	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
 	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
 	td->elements       = asn_DEF_ENUMERATED.elements;
 	td->elements_count = asn_DEF_ENUMERATED.elements_count;
      /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
@@ -740,22 +797,22 @@
 
 /*** <<< STAT-DEFS [EnumType] >>> ***/
 
-static asn_INTEGER_enum_map_t asn_MAP_EnumType_1_value2enum[] = {
+static asn_INTEGER_enum_map_t asn_MAP_EnumType_value2enum_1[] = {
 	{ 0,	3,	"one" },
 	{ 1,	3,	"two" }
 };
-static unsigned int asn_MAP_EnumType_1_enum2value[] = {
+static unsigned int asn_MAP_EnumType_enum2value_1[] = {
 	0,	/* one(0) */
 	1	/* two(1) */
 };
-static asn_INTEGER_specifics_t asn_SPC_EnumType_1_specs = {
-	asn_MAP_EnumType_1_value2enum,	/* "tag" => N; sorted by tag */
-	asn_MAP_EnumType_1_enum2value,	/* N => "tag"; sorted by N */
+static asn_INTEGER_specifics_t asn_SPC_EnumType_specs_1 = {
+	asn_MAP_EnumType_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_EnumType_enum2value_1,	/* 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_EnumType_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_EnumType_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_EnumType = {
@@ -768,14 +825,16 @@
 	EnumType_encode_der,
 	EnumType_decode_xer,
 	EnumType_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_EnumType_1_tags,
-	sizeof(asn_DEF_EnumType_1_tags)
-		/sizeof(asn_DEF_EnumType_1_tags[0]), /* 1 */
-	asn_DEF_EnumType_1_tags,	/* Same as above */
-	sizeof(asn_DEF_EnumType_1_tags)
-		/sizeof(asn_DEF_EnumType_1_tags[0]), /* 1 */
+	asn_DEF_EnumType_tags_1,
+	sizeof(asn_DEF_EnumType_tags_1)
+		/sizeof(asn_DEF_EnumType_tags_1[0]), /* 1 */
+	asn_DEF_EnumType_tags_1,	/* Same as above */
+	sizeof(asn_DEF_EnumType_tags_1)
+		/sizeof(asn_DEF_EnumType_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
-	&asn_SPC_EnumType_1_specs	/* Additional specs */
+	&asn_SPC_EnumType_specs_1	/* Additional specs */
 };
 
diff --git a/tests/84-param-tags-OK.asn1.-P b/tests/84-param-tags-OK.asn1.-P
index 6598764..f7353db 100644
--- a/tests/84-param-tags-OK.asn1.-P
+++ b/tests/84-param-tags-OK.asn1.-P
@@ -20,13 +20,13 @@
 	TestChoice_PR present;
 	union TestChoice_u {
 		struct type1 {
-			long	*common	/* DEFAULT 0 */;
+			long	 common	/* DEFAULT 0 */;
 			
 			/* Context for parsing across buffer boundaries */
 			asn_struct_ctx_t _asn_ctx;
 		} type1;
 		struct type2 {
-			BOOLEAN_t	*common	/* DEFAULT 0 */;
+			BOOLEAN_t	 common	/* DEFAULT 0 */;
 			
 			/* Context for parsing across buffer boundaries */
 			asn_struct_ctx_t _asn_ctx;
@@ -44,7 +44,7 @@
 /*** <<< CODE [TestChoice] >>> ***/
 
 static int
-memb_common_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_common_constraint_2(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	long value;
 	
@@ -71,26 +71,41 @@
 
 /*** <<< STAT-DEFS [TestChoice] >>> ***/
 
+static int asn_DFL_3_set_0(void **sptr) {
+	long *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 0 */
+	*st = 0;
+	return 0;
+}
 static asn_TYPE_member_t asn_MBR_type1_2[] = {
-	{ ATF_POINTER, 1, offsetof(struct type1, common),
+	{ ATF_NOFLAGS, 1, offsetof(struct type1, common),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_NativeInteger,
-		.memb_constraints = memb_common_2_constraint,
+		.memb_constraints = memb_common_constraint_2,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = asn_DFL_3_set_0,	/* DEFAULT 0 */
 		.name = "common"
 		},
 };
-static ber_tlv_tag_t asn_DEF_type1_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_type1_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_type1_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_type1_tag2el_2[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* common at 20 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_type1_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_type1_specs_2 = {
 	sizeof(struct type1),
 	offsetof(struct type1, _asn_ctx),
-	asn_MAP_type1_2_tag2el,
+	asn_MAP_type1_tag2el_2,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -105,39 +120,56 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_type1_2_tags,
-	sizeof(asn_DEF_type1_2_tags)
-		/sizeof(asn_DEF_type1_2_tags[0]), /* 1 */
-	asn_DEF_type1_2_tags,	/* Same as above */
-	sizeof(asn_DEF_type1_2_tags)
-		/sizeof(asn_DEF_type1_2_tags[0]), /* 1 */
+	asn_DEF_type1_tags_2,
+	sizeof(asn_DEF_type1_tags_2)
+		/sizeof(asn_DEF_type1_tags_2[0]), /* 1 */
+	asn_DEF_type1_tags_2,	/* Same as above */
+	sizeof(asn_DEF_type1_tags_2)
+		/sizeof(asn_DEF_type1_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_type1_2,
 	1,	/* Elements count */
-	&asn_SPC_type1_2_specs	/* Additional specs */
+	&asn_SPC_type1_specs_2	/* Additional specs */
 };
 
+static int asn_DFL_5_set_0(void **sptr) {
+	BOOLEAN_t *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 0 */
+	*st = 0;
+	return 0;
+}
 static asn_TYPE_member_t asn_MBR_type2_4[] = {
-	{ ATF_POINTER, 1, offsetof(struct type2, common),
+	{ ATF_NOFLAGS, 1, offsetof(struct type2, common),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_BOOLEAN,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = asn_DFL_5_set_0,	/* DEFAULT 0 */
 		.name = "common"
 		},
 };
-static ber_tlv_tag_t asn_DEF_type2_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_type2_tags_4[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_type2_4_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_type2_tag2el_4[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 0, 0, 0 } /* common at 21 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_type2_4_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_type2_specs_4 = {
 	sizeof(struct type2),
 	offsetof(struct type2, _asn_ctx),
-	asn_MAP_type2_4_tag2el,
+	asn_MAP_type2_tag2el_4,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -152,16 +184,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_type2_4_tags,
-	sizeof(asn_DEF_type2_4_tags)
-		/sizeof(asn_DEF_type2_4_tags[0]) - 1, /* 1 */
-	asn_DEF_type2_4_tags,	/* Same as above */
-	sizeof(asn_DEF_type2_4_tags)
-		/sizeof(asn_DEF_type2_4_tags[0]), /* 2 */
+	asn_DEF_type2_tags_4,
+	sizeof(asn_DEF_type2_tags_4)
+		/sizeof(asn_DEF_type2_tags_4[0]) - 1, /* 1 */
+	asn_DEF_type2_tags_4,	/* Same as above */
+	sizeof(asn_DEF_type2_tags_4)
+		/sizeof(asn_DEF_type2_tags_4[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_type2_4,
 	1,	/* Elements count */
-	&asn_SPC_type2_4_specs	/* Additional specs */
+	&asn_SPC_type2_specs_4	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_TestChoice_1[] = {
@@ -170,6 +204,8 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_type1_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "type1"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct TestChoice, choice.type2),
@@ -177,21 +213,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_type2_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "type2"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_TestChoice_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_TestChoice_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* type1 at 16 */
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, 0, 0 } /* type2 at 16 */
 };
-static asn_CHOICE_specifics_t asn_SPC_TestChoice_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_TestChoice_specs_1 = {
 	sizeof(struct TestChoice),
 	offsetof(struct TestChoice, _asn_ctx),
 	offsetof(struct TestChoice, present),
 	sizeof(((struct TestChoice *)0)->present),
-	asn_MAP_TestChoice_1_tag2el,
+	asn_MAP_TestChoice_tag2el_1,
 	2,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_TestChoice = {
 	"TestChoice",
@@ -203,14 +242,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_TestChoice_1,
 	2,	/* Elements count */
-	&asn_SPC_TestChoice_1_specs	/* Additional specs */
+	&asn_SPC_TestChoice_specs_1	/* Additional specs */
 };
 
 
@@ -259,7 +300,7 @@
 /*** <<< CODE [AutoChoice] >>> ***/
 
 static int
-memb_common_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_common_constraint_2(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	long value;
 	
@@ -284,7 +325,7 @@
 }
 
 static int
-memb_common_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_common_constraint_4(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	BOOLEAN_t value;
 	
@@ -316,22 +357,25 @@
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_NativeInteger,
-		.memb_constraints = memb_common_2_constraint,
+		.memb_constraints = memb_common_constraint_2,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "common"
 		},
 };
-static ber_tlv_tag_t asn_DEF_type1_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_type1_tags_2[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_type1_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_type1_tag2el_2[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* common at 37 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_type1_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_type1_specs_2 = {
 	sizeof(struct type1),
 	offsetof(struct type1, _asn_ctx),
-	asn_MAP_type1_2_tag2el,
+	asn_MAP_type1_tag2el_2,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -346,16 +390,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_type1_2_tags,
-	sizeof(asn_DEF_type1_2_tags)
-		/sizeof(asn_DEF_type1_2_tags[0]) - 1, /* 1 */
-	asn_DEF_type1_2_tags,	/* Same as above */
-	sizeof(asn_DEF_type1_2_tags)
-		/sizeof(asn_DEF_type1_2_tags[0]), /* 2 */
+	asn_DEF_type1_tags_2,
+	sizeof(asn_DEF_type1_tags_2)
+		/sizeof(asn_DEF_type1_tags_2[0]) - 1, /* 1 */
+	asn_DEF_type1_tags_2,	/* Same as above */
+	sizeof(asn_DEF_type1_tags_2)
+		/sizeof(asn_DEF_type1_tags_2[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_type1_2,
 	1,	/* Elements count */
-	&asn_SPC_type1_2_specs	/* Additional specs */
+	&asn_SPC_type1_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_type2_4[] = {
@@ -363,22 +409,25 @@
 		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_BOOLEAN,
-		.memb_constraints = memb_common_4_constraint,
+		.memb_constraints = memb_common_constraint_4,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "common"
 		},
 };
-static ber_tlv_tag_t asn_DEF_type2_4_tags[] = {
+static ber_tlv_tag_t asn_DEF_type2_tags_4[] = {
 	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_type2_4_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_type2_tag2el_4[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* common at 38 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_type2_4_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_type2_specs_4 = {
 	sizeof(struct type2),
 	offsetof(struct type2, _asn_ctx),
-	asn_MAP_type2_4_tag2el,
+	asn_MAP_type2_tag2el_4,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -393,16 +442,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_type2_4_tags,
-	sizeof(asn_DEF_type2_4_tags)
-		/sizeof(asn_DEF_type2_4_tags[0]) - 1, /* 1 */
-	asn_DEF_type2_4_tags,	/* Same as above */
-	sizeof(asn_DEF_type2_4_tags)
-		/sizeof(asn_DEF_type2_4_tags[0]), /* 2 */
+	asn_DEF_type2_tags_4,
+	sizeof(asn_DEF_type2_tags_4)
+		/sizeof(asn_DEF_type2_tags_4[0]) - 1, /* 1 */
+	asn_DEF_type2_tags_4,	/* Same as above */
+	sizeof(asn_DEF_type2_tags_4)
+		/sizeof(asn_DEF_type2_tags_4[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_type2_4,
 	1,	/* Elements count */
-	&asn_SPC_type2_4_specs	/* Additional specs */
+	&asn_SPC_type2_specs_4	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_AutoChoice_1[] = {
@@ -411,6 +462,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_type1_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "type1"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct AutoChoice, choice.type2),
@@ -418,21 +471,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_type2_4,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "type2"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_AutoChoice_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_AutoChoice_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* type1 at 34 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* type2 at 34 */
 };
-static asn_CHOICE_specifics_t asn_SPC_AutoChoice_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_AutoChoice_specs_1 = {
 	sizeof(struct AutoChoice),
 	offsetof(struct AutoChoice, _asn_ctx),
 	offsetof(struct AutoChoice, present),
 	sizeof(((struct AutoChoice *)0)->present),
-	asn_MAP_AutoChoice_1_tag2el,
+	asn_MAP_AutoChoice_tag2el_1,
 	2,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_AutoChoice = {
 	"AutoChoice",
@@ -444,13 +500,15 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_AutoChoice_1,
 	2,	/* Elements count */
-	&asn_SPC_AutoChoice_1_specs	/* Additional specs */
+	&asn_SPC_AutoChoice_specs_1	/* Additional specs */
 };
 
diff --git a/tests/88-integer-enum-OK.asn1.-P b/tests/88-integer-enum-OK.asn1.-P
index d87bda5..6b73d31 100644
--- a/tests/88-integer-enum-OK.asn1.-P
+++ b/tests/88-integer-enum-OK.asn1.-P
@@ -47,6 +47,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -99,7 +102,7 @@
 
 /*** <<< STAT-DEFS [T] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_T_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_T = {
@@ -112,13 +115,15 @@
 	T_encode_der,
 	T_decode_xer,
 	T_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_T_tags_1,
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	asn_DEF_T_tags_1,	/* Same as above */
+	sizeof(asn_DEF_T_tags_1)
+		/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
diff --git a/tests/89-bit-string-enum-OK.asn1.-P b/tests/89-bit-string-enum-OK.asn1.-P
index 158a444..0514dad 100644
--- a/tests/89-bit-string-enum-OK.asn1.-P
+++ b/tests/89-bit-string-enum-OK.asn1.-P
@@ -39,20 +39,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_BIT_STRING,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "bs"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 0, 0, 0 } /* bs at 15 */
 };
-static asn_CHOICE_specifics_t asn_SPC_T_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_T_specs_1 = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
 	offsetof(struct T, present),
 	sizeof(((struct T *)0)->present),
-	asn_MAP_T_1_tag2el,
+	asn_MAP_T_tag2el_1,
 	1,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_T = {
 	"T",
@@ -64,13 +67,15 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_T_1,
 	1,	/* Elements count */
-	&asn_SPC_T_1_specs	/* Additional specs */
+	&asn_SPC_T_specs_1	/* Additional specs */
 };
 
diff --git a/tests/89-bit-string-enum-OK.asn1.-Pfcompound-names b/tests/89-bit-string-enum-OK.asn1.-Pfcompound-names
index 8f5d06c..dbea3a3 100644
--- a/tests/89-bit-string-enum-OK.asn1.-Pfcompound-names
+++ b/tests/89-bit-string-enum-OK.asn1.-Pfcompound-names
@@ -39,20 +39,23 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_BIT_STRING,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "bs"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_T_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_T_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 0, 0, 0 } /* bs at 15 */
 };
-static asn_CHOICE_specifics_t asn_SPC_T_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_T_specs_1 = {
 	sizeof(struct T),
 	offsetof(struct T, _asn_ctx),
 	offsetof(struct T, present),
 	sizeof(((struct T *)0)->present),
-	asn_MAP_T_1_tag2el,
+	asn_MAP_T_tag2el_1,
 	1,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_T = {
 	"T",
@@ -64,13 +67,15 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_T_1,
 	1,	/* Elements count */
-	&asn_SPC_T_1_specs	/* Additional specs */
+	&asn_SPC_T_specs_1	/* Additional specs */
 };
 
diff --git a/tests/90-cond-int-type-OK.asn1.-P b/tests/90-cond-int-type-OK.asn1.-P
index 89acc3f..9e03bc2 100644
--- a/tests/90-cond-int-type-OK.asn1.-P
+++ b/tests/90-cond-int-type-OK.asn1.-P
@@ -40,6 +40,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -92,7 +95,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerUnlimited] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited = {
@@ -105,13 +108,15 @@
 	CN_IntegerUnlimited_encode_der,
 	CN_IntegerUnlimited_decode_xer,
 	CN_IntegerUnlimited_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerUnlimited_1_tags,
-	sizeof(asn_DEF_CN_IntegerUnlimited_1_tags)
-		/sizeof(asn_DEF_CN_IntegerUnlimited_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerUnlimited_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerUnlimited_1_tags)
-		/sizeof(asn_DEF_CN_IntegerUnlimited_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerUnlimited_tags_1,
+	sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
+		/sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerUnlimited_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
+		/sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -172,6 +177,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -224,7 +232,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerMinMax] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax = {
@@ -237,13 +245,15 @@
 	CN_IntegerMinMax_encode_der,
 	CN_IntegerMinMax_decode_xer,
 	CN_IntegerMinMax_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerMinMax_1_tags,
-	sizeof(asn_DEF_CN_IntegerMinMax_1_tags)
-		/sizeof(asn_DEF_CN_IntegerMinMax_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerMinMax_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerMinMax_1_tags)
-		/sizeof(asn_DEF_CN_IntegerMinMax_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerMinMax_tags_1,
+	sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerMinMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -313,6 +323,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -365,7 +378,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerMinLow] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow = {
@@ -378,13 +391,15 @@
 	CN_IntegerMinLow_encode_der,
 	CN_IntegerMinLow_decode_xer,
 	CN_IntegerMinLow_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerMinLow_1_tags,
-	sizeof(asn_DEF_CN_IntegerMinLow_1_tags)
-		/sizeof(asn_DEF_CN_IntegerMinLow_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerMinLow_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerMinLow_1_tags)
-		/sizeof(asn_DEF_CN_IntegerMinLow_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerMinLow_tags_1,
+	sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerMinLow_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -454,6 +469,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -506,7 +524,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerMinHigh] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
@@ -519,13 +537,15 @@
 	NO_IntegerMinHigh_encode_der,
 	NO_IntegerMinHigh_decode_xer,
 	NO_IntegerMinHigh_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerMinHigh_1_tags,
-	sizeof(asn_DEF_NO_IntegerMinHigh_1_tags)
-		/sizeof(asn_DEF_NO_IntegerMinHigh_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerMinHigh_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerMinHigh_1_tags)
-		/sizeof(asn_DEF_NO_IntegerMinHigh_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerMinHigh_tags_1,
+	sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerMinHigh_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -595,6 +615,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -647,7 +670,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerLowHigh] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
@@ -660,13 +683,15 @@
 	NO_IntegerLowHigh_encode_der,
 	NO_IntegerLowHigh_decode_xer,
 	NO_IntegerLowHigh_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerLowHigh_1_tags,
-	sizeof(asn_DEF_NO_IntegerLowHigh_1_tags)
-		/sizeof(asn_DEF_NO_IntegerLowHigh_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerLowHigh_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerLowHigh_1_tags)
-		/sizeof(asn_DEF_NO_IntegerLowHigh_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerLowHigh_tags_1,
+	sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerLowHigh_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -736,6 +761,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -788,7 +816,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerLowMax] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax = {
@@ -801,13 +829,15 @@
 	CN_IntegerLowMax_encode_der,
 	CN_IntegerLowMax_decode_xer,
 	CN_IntegerLowMax_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerLowMax_1_tags,
-	sizeof(asn_DEF_CN_IntegerLowMax_1_tags)
-		/sizeof(asn_DEF_CN_IntegerLowMax_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerLowMax_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerLowMax_1_tags)
-		/sizeof(asn_DEF_CN_IntegerLowMax_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerLowMax_tags_1,
+	sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerLowMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -877,6 +907,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -929,7 +962,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerHighMax] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax = {
@@ -942,13 +975,15 @@
 	NO_IntegerHighMax_encode_der,
 	NO_IntegerHighMax_decode_xer,
 	NO_IntegerHighMax_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerHighMax_1_tags,
-	sizeof(asn_DEF_NO_IntegerHighMax_1_tags)
-		/sizeof(asn_DEF_NO_IntegerHighMax_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerHighMax_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerHighMax_1_tags)
-		/sizeof(asn_DEF_NO_IntegerHighMax_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerHighMax_tags_1,
+	sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerHighMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1018,6 +1053,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -1070,7 +1108,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerLowestMax] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
@@ -1083,13 +1121,15 @@
 	NO_IntegerLowestMax_encode_der,
 	NO_IntegerLowestMax_decode_xer,
 	NO_IntegerLowestMax_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerLowestMax_1_tags,
-	sizeof(asn_DEF_NO_IntegerLowestMax_1_tags)
-		/sizeof(asn_DEF_NO_IntegerLowestMax_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerLowestMax_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerLowestMax_1_tags)
-		/sizeof(asn_DEF_NO_IntegerLowestMax_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerLowestMax_tags_1,
+	sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerLowestMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1159,6 +1199,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -1211,7 +1254,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
@@ -1224,13 +1267,15 @@
 	NO_IntegerOutRange_encode_der,
 	NO_IntegerOutRange_decode_xer,
 	NO_IntegerOutRange_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerOutRange_1_tags,
-	sizeof(asn_DEF_NO_IntegerOutRange_1_tags)
-		/sizeof(asn_DEF_NO_IntegerOutRange_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerOutRange_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerOutRange_1_tags)
-		/sizeof(asn_DEF_NO_IntegerOutRange_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerOutRange_tags_1,
+	sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerOutRange_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1300,6 +1345,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -1352,7 +1400,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
@@ -1365,13 +1413,15 @@
 	NO_IntegerOutValue_encode_der,
 	NO_IntegerOutValue_decode_xer,
 	NO_IntegerOutValue_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerOutValue_1_tags,
-	sizeof(asn_DEF_NO_IntegerOutValue_1_tags)
-		/sizeof(asn_DEF_NO_IntegerOutValue_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerOutValue_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerOutValue_1_tags)
-		/sizeof(asn_DEF_NO_IntegerOutValue_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerOutValue_tags_1,
+	sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerOutValue_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1435,6 +1485,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -1487,7 +1540,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1 = {
@@ -1500,13 +1553,15 @@
 	OK_IntegerInRange1_encode_der,
 	OK_IntegerInRange1_decode_xer,
 	OK_IntegerInRange1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange1_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange1_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange1_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange1_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange1_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange1_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1570,6 +1625,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -1622,7 +1680,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2 = {
@@ -1635,13 +1693,15 @@
 	OK_IntegerInRange2_encode_der,
 	OK_IntegerInRange2_decode_xer,
 	OK_IntegerInRange2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange2_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange2_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange2_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange2_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange2_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange2_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1705,6 +1765,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -1757,7 +1820,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3 = {
@@ -1770,13 +1833,15 @@
 	OK_IntegerInRange3_encode_der,
 	OK_IntegerInRange3_decode_xer,
 	OK_IntegerInRange3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange3_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange3_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange3_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange3_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange3_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange3_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange3_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1840,6 +1905,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -1892,7 +1960,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4 = {
@@ -1905,13 +1973,15 @@
 	OK_IntegerInRange4_encode_der,
 	OK_IntegerInRange4_decode_xer,
 	OK_IntegerInRange4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange4_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange4_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange4_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange4_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange4_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange4_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange4_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1981,6 +2051,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -2033,7 +2106,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
@@ -2046,13 +2119,15 @@
 	OK_IntegerInRange5_encode_der,
 	OK_IntegerInRange5_decode_xer,
 	OK_IntegerInRange5_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange5_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange5_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange5_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange5_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange5_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange5_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange5_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2122,6 +2197,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -2174,7 +2252,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
@@ -2187,13 +2265,15 @@
 	NO_IntegerInRange6_encode_der,
 	NO_IntegerInRange6_decode_xer,
 	NO_IntegerInRange6_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerInRange6_1_tags,
-	sizeof(asn_DEF_NO_IntegerInRange6_1_tags)
-		/sizeof(asn_DEF_NO_IntegerInRange6_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerInRange6_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerInRange6_1_tags)
-		/sizeof(asn_DEF_NO_IntegerInRange6_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerInRange6_tags_1,
+	sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
+		/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerInRange6_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
+		/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2247,6 +2327,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -2299,7 +2382,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerEnumerated1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1 = {
@@ -2312,13 +2395,15 @@
 	CN_IntegerEnumerated1_encode_der,
 	CN_IntegerEnumerated1_decode_xer,
 	CN_IntegerEnumerated1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerEnumerated1_1_tags,
-	sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags)
-		/sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerEnumerated1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags)
-		/sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerEnumerated1_tags_1,
+	sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
+		/sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerEnumerated1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
+		/sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -2372,6 +2457,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -2424,7 +2512,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerEnumerated2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2 = {
@@ -2437,13 +2525,15 @@
 	NO_IntegerEnumerated2_encode_der,
 	NO_IntegerEnumerated2_decode_xer,
 	NO_IntegerEnumerated2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerEnumerated2_1_tags,
-	sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags)
-		/sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerEnumerated2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags)
-		/sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerEnumerated2_tags_1,
+	sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
+		/sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerEnumerated2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
+		/sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
diff --git a/tests/90-cond-int-type-OK.asn1.-Pfnative-types b/tests/90-cond-int-type-OK.asn1.-Pfnative-types
index eaf0f53..240c70b 100644
--- a/tests/90-cond-int-type-OK.asn1.-Pfnative-types
+++ b/tests/90-cond-int-type-OK.asn1.-Pfnative-types
@@ -40,6 +40,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -92,7 +95,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerUnlimited] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited = {
@@ -105,13 +108,15 @@
 	CN_IntegerUnlimited_encode_der,
 	CN_IntegerUnlimited_decode_xer,
 	CN_IntegerUnlimited_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerUnlimited_1_tags,
-	sizeof(asn_DEF_CN_IntegerUnlimited_1_tags)
-		/sizeof(asn_DEF_CN_IntegerUnlimited_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerUnlimited_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerUnlimited_1_tags)
-		/sizeof(asn_DEF_CN_IntegerUnlimited_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerUnlimited_tags_1,
+	sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
+		/sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerUnlimited_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
+		/sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -171,6 +176,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -223,7 +231,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerMinMax] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax = {
@@ -236,13 +244,15 @@
 	CN_IntegerMinMax_encode_der,
 	CN_IntegerMinMax_decode_xer,
 	CN_IntegerMinMax_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerMinMax_1_tags,
-	sizeof(asn_DEF_CN_IntegerMinMax_1_tags)
-		/sizeof(asn_DEF_CN_IntegerMinMax_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerMinMax_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerMinMax_1_tags)
-		/sizeof(asn_DEF_CN_IntegerMinMax_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerMinMax_tags_1,
+	sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerMinMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -306,6 +316,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -358,7 +371,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerMinLow] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow = {
@@ -371,13 +384,15 @@
 	CN_IntegerMinLow_encode_der,
 	CN_IntegerMinLow_decode_xer,
 	CN_IntegerMinLow_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerMinLow_1_tags,
-	sizeof(asn_DEF_CN_IntegerMinLow_1_tags)
-		/sizeof(asn_DEF_CN_IntegerMinLow_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerMinLow_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerMinLow_1_tags)
-		/sizeof(asn_DEF_CN_IntegerMinLow_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerMinLow_tags_1,
+	sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerMinLow_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -447,6 +462,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -499,7 +517,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerMinHigh] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
@@ -512,13 +530,15 @@
 	NO_IntegerMinHigh_encode_der,
 	NO_IntegerMinHigh_decode_xer,
 	NO_IntegerMinHigh_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerMinHigh_1_tags,
-	sizeof(asn_DEF_NO_IntegerMinHigh_1_tags)
-		/sizeof(asn_DEF_NO_IntegerMinHigh_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerMinHigh_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerMinHigh_1_tags)
-		/sizeof(asn_DEF_NO_IntegerMinHigh_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerMinHigh_tags_1,
+	sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerMinHigh_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -588,6 +608,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -640,7 +663,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerLowHigh] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
@@ -653,13 +676,15 @@
 	NO_IntegerLowHigh_encode_der,
 	NO_IntegerLowHigh_decode_xer,
 	NO_IntegerLowHigh_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerLowHigh_1_tags,
-	sizeof(asn_DEF_NO_IntegerLowHigh_1_tags)
-		/sizeof(asn_DEF_NO_IntegerLowHigh_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerLowHigh_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerLowHigh_1_tags)
-		/sizeof(asn_DEF_NO_IntegerLowHigh_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerLowHigh_tags_1,
+	sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerLowHigh_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -723,6 +748,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -775,7 +803,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerLowMax] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax = {
@@ -788,13 +816,15 @@
 	CN_IntegerLowMax_encode_der,
 	CN_IntegerLowMax_decode_xer,
 	CN_IntegerLowMax_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerLowMax_1_tags,
-	sizeof(asn_DEF_CN_IntegerLowMax_1_tags)
-		/sizeof(asn_DEF_CN_IntegerLowMax_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerLowMax_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerLowMax_1_tags)
-		/sizeof(asn_DEF_CN_IntegerLowMax_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerLowMax_tags_1,
+	sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerLowMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -864,6 +894,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -916,7 +949,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerHighMax] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax = {
@@ -929,13 +962,15 @@
 	NO_IntegerHighMax_encode_der,
 	NO_IntegerHighMax_decode_xer,
 	NO_IntegerHighMax_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerHighMax_1_tags,
-	sizeof(asn_DEF_NO_IntegerHighMax_1_tags)
-		/sizeof(asn_DEF_NO_IntegerHighMax_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerHighMax_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerHighMax_1_tags)
-		/sizeof(asn_DEF_NO_IntegerHighMax_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerHighMax_tags_1,
+	sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerHighMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1005,6 +1040,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -1057,7 +1095,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerLowestMax] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
@@ -1070,13 +1108,15 @@
 	NO_IntegerLowestMax_encode_der,
 	NO_IntegerLowestMax_decode_xer,
 	NO_IntegerLowestMax_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerLowestMax_1_tags,
-	sizeof(asn_DEF_NO_IntegerLowestMax_1_tags)
-		/sizeof(asn_DEF_NO_IntegerLowestMax_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerLowestMax_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerLowestMax_1_tags)
-		/sizeof(asn_DEF_NO_IntegerLowestMax_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerLowestMax_tags_1,
+	sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerLowestMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1146,6 +1186,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -1198,7 +1241,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
@@ -1211,13 +1254,15 @@
 	NO_IntegerOutRange_encode_der,
 	NO_IntegerOutRange_decode_xer,
 	NO_IntegerOutRange_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerOutRange_1_tags,
-	sizeof(asn_DEF_NO_IntegerOutRange_1_tags)
-		/sizeof(asn_DEF_NO_IntegerOutRange_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerOutRange_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerOutRange_1_tags)
-		/sizeof(asn_DEF_NO_IntegerOutRange_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerOutRange_tags_1,
+	sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerOutRange_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1287,6 +1332,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -1339,7 +1387,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
@@ -1352,13 +1400,15 @@
 	NO_IntegerOutValue_encode_der,
 	NO_IntegerOutValue_decode_xer,
 	NO_IntegerOutValue_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerOutValue_1_tags,
-	sizeof(asn_DEF_NO_IntegerOutValue_1_tags)
-		/sizeof(asn_DEF_NO_IntegerOutValue_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerOutValue_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerOutValue_1_tags)
-		/sizeof(asn_DEF_NO_IntegerOutValue_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerOutValue_tags_1,
+	sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerOutValue_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1422,6 +1472,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -1474,7 +1527,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1 = {
@@ -1487,13 +1540,15 @@
 	OK_IntegerInRange1_encode_der,
 	OK_IntegerInRange1_decode_xer,
 	OK_IntegerInRange1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange1_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange1_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange1_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange1_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange1_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange1_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1557,6 +1612,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -1609,7 +1667,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2 = {
@@ -1622,13 +1680,15 @@
 	OK_IntegerInRange2_encode_der,
 	OK_IntegerInRange2_decode_xer,
 	OK_IntegerInRange2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange2_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange2_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange2_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange2_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange2_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange2_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1692,6 +1752,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -1744,7 +1807,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3 = {
@@ -1757,13 +1820,15 @@
 	OK_IntegerInRange3_encode_der,
 	OK_IntegerInRange3_decode_xer,
 	OK_IntegerInRange3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange3_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange3_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange3_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange3_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange3_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange3_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange3_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1827,6 +1892,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -1879,7 +1947,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4 = {
@@ -1892,13 +1960,15 @@
 	OK_IntegerInRange4_encode_der,
 	OK_IntegerInRange4_decode_xer,
 	OK_IntegerInRange4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange4_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange4_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange4_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange4_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange4_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange4_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange4_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -1962,6 +2032,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -2014,7 +2087,7 @@
 
 /*** <<< STAT-DEFS [OK-IntegerInRange5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
@@ -2027,13 +2100,15 @@
 	OK_IntegerInRange5_encode_der,
 	OK_IntegerInRange5_decode_xer,
 	OK_IntegerInRange5_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_IntegerInRange5_1_tags,
-	sizeof(asn_DEF_OK_IntegerInRange5_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange5_1_tags[0]), /* 1 */
-	asn_DEF_OK_IntegerInRange5_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_IntegerInRange5_1_tags)
-		/sizeof(asn_DEF_OK_IntegerInRange5_1_tags[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange5_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2103,6 +2178,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -2155,7 +2233,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
@@ -2168,13 +2246,15 @@
 	NO_IntegerInRange6_encode_der,
 	NO_IntegerInRange6_decode_xer,
 	NO_IntegerInRange6_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerInRange6_1_tags,
-	sizeof(asn_DEF_NO_IntegerInRange6_1_tags)
-		/sizeof(asn_DEF_NO_IntegerInRange6_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerInRange6_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerInRange6_1_tags)
-		/sizeof(asn_DEF_NO_IntegerInRange6_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerInRange6_tags_1,
+	sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
+		/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerInRange6_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
+		/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -2228,6 +2308,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -2280,7 +2363,7 @@
 
 /*** <<< STAT-DEFS [CN-IntegerEnumerated1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1 = {
@@ -2293,13 +2376,15 @@
 	CN_IntegerEnumerated1_encode_der,
 	CN_IntegerEnumerated1_decode_xer,
 	CN_IntegerEnumerated1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_CN_IntegerEnumerated1_1_tags,
-	sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags)
-		/sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags[0]), /* 1 */
-	asn_DEF_CN_IntegerEnumerated1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags)
-		/sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags[0]), /* 1 */
+	asn_DEF_CN_IntegerEnumerated1_tags_1,
+	sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
+		/sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerEnumerated1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
+		/sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -2353,6 +2438,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -2405,7 +2493,7 @@
 
 /*** <<< STAT-DEFS [NO-IntegerEnumerated2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2 = {
@@ -2418,13 +2506,15 @@
 	NO_IntegerEnumerated2_encode_der,
 	NO_IntegerEnumerated2_decode_xer,
 	NO_IntegerEnumerated2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_IntegerEnumerated2_1_tags,
-	sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags)
-		/sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags[0]), /* 1 */
-	asn_DEF_NO_IntegerEnumerated2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags)
-		/sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags[0]), /* 1 */
+	asn_DEF_NO_IntegerEnumerated2_tags_1,
+	sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
+		/sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerEnumerated2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
+		/sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
diff --git a/tests/90-cond-int-type-OK.asn1.-Pgen-PER b/tests/90-cond-int-type-OK.asn1.-Pgen-PER
new file mode 100644
index 0000000..e0951e4
--- /dev/null
+++ b/tests/90-cond-int-type-OK.asn1.-Pgen-PER
@@ -0,0 +1,2744 @@
+
+/*** <<< INCLUDES [CN-IntegerUnlimited] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [CN-IntegerUnlimited] >>> ***/
+
+typedef INTEGER_t	 CN_IntegerUnlimited_t;
+
+/*** <<< FUNC-DECLS [CN-IntegerUnlimited] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited;
+asn_struct_free_f CN_IntegerUnlimited_free;
+asn_struct_print_f CN_IntegerUnlimited_print;
+asn_constr_check_f CN_IntegerUnlimited_constraint;
+ber_type_decoder_f CN_IntegerUnlimited_decode_ber;
+der_type_encoder_f CN_IntegerUnlimited_encode_der;
+xer_type_decoder_f CN_IntegerUnlimited_decode_xer;
+xer_type_encoder_f CN_IntegerUnlimited_encode_xer;
+per_type_decoder_f CN_IntegerUnlimited_decode_uper;
+
+/*** <<< CODE [CN-IntegerUnlimited] >>> ***/
+
+int
+CN_IntegerUnlimited_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
+CN_IntegerUnlimited_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+CN_IntegerUnlimited_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CN_IntegerUnlimited_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerUnlimited_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CN_IntegerUnlimited_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) {
+	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerUnlimited_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CN_IntegerUnlimited_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) {
+	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerUnlimited_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [CN-IntegerUnlimited] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited = {
+	"CN-IntegerUnlimited",
+	"CN-IntegerUnlimited",
+	CN_IntegerUnlimited_free,
+	CN_IntegerUnlimited_print,
+	CN_IntegerUnlimited_constraint,
+	CN_IntegerUnlimited_decode_ber,
+	CN_IntegerUnlimited_encode_der,
+	CN_IntegerUnlimited_decode_xer,
+	CN_IntegerUnlimited_encode_xer,
+	CN_IntegerUnlimited_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CN_IntegerUnlimited_tags_1,
+	sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
+		/sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerUnlimited_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
+		/sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [CN-IntegerMinMax] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [CN-IntegerMinMax] >>> ***/
+
+typedef INTEGER_t	 CN_IntegerMinMax_t;
+
+/*** <<< FUNC-DECLS [CN-IntegerMinMax] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax;
+asn_struct_free_f CN_IntegerMinMax_free;
+asn_struct_print_f CN_IntegerMinMax_print;
+asn_constr_check_f CN_IntegerMinMax_constraint;
+ber_type_decoder_f CN_IntegerMinMax_decode_ber;
+der_type_encoder_f CN_IntegerMinMax_encode_der;
+xer_type_decoder_f CN_IntegerMinMax_decode_xer;
+xer_type_encoder_f CN_IntegerMinMax_encode_xer;
+per_type_decoder_f CN_IntegerMinMax_decode_uper;
+
+/*** <<< CODE [CN-IntegerMinMax] >>> ***/
+
+int
+CN_IntegerMinMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(1 /* No applicable constraints whatsoever */) {
+		/* Nothing is here. See below */
+	}
+	
+	/* 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
+CN_IntegerMinMax_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+CN_IntegerMinMax_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CN_IntegerMinMax_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerMinMax_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CN_IntegerMinMax_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) {
+	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerMinMax_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CN_IntegerMinMax_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) {
+	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerMinMax_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [CN-IntegerMinMax] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_CN_IntegerMinMax_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax = {
+	"CN-IntegerMinMax",
+	"CN-IntegerMinMax",
+	CN_IntegerMinMax_free,
+	CN_IntegerMinMax_print,
+	CN_IntegerMinMax_constraint,
+	CN_IntegerMinMax_decode_ber,
+	CN_IntegerMinMax_encode_der,
+	CN_IntegerMinMax_decode_xer,
+	CN_IntegerMinMax_encode_xer,
+	CN_IntegerMinMax_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CN_IntegerMinMax_tags_1,
+	sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerMinMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
+	&asn_PER_CN_IntegerMinMax_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [CN-IntegerMinLow] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [CN-IntegerMinLow] >>> ***/
+
+typedef INTEGER_t	 CN_IntegerMinLow_t;
+
+/*** <<< FUNC-DECLS [CN-IntegerMinLow] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow;
+asn_struct_free_f CN_IntegerMinLow_free;
+asn_struct_print_f CN_IntegerMinLow_print;
+asn_constr_check_f CN_IntegerMinLow_constraint;
+ber_type_decoder_f CN_IntegerMinLow_decode_ber;
+der_type_encoder_f CN_IntegerMinLow_encode_der;
+xer_type_decoder_f CN_IntegerMinLow_decode_xer;
+xer_type_encoder_f CN_IntegerMinLow_encode_xer;
+per_type_decoder_f CN_IntegerMinLow_decode_uper;
+
+/*** <<< CODE [CN-IntegerMinLow] >>> ***/
+
+int
+CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value <= 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CN_IntegerMinLow_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+CN_IntegerMinLow_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CN_IntegerMinLow_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerMinLow_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CN_IntegerMinLow_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) {
+	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerMinLow_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CN_IntegerMinLow_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) {
+	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerMinLow_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [CN-IntegerMinLow] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_CN_IntegerMinLow_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }	/* (MIN..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow = {
+	"CN-IntegerMinLow",
+	"CN-IntegerMinLow",
+	CN_IntegerMinLow_free,
+	CN_IntegerMinLow_print,
+	CN_IntegerMinLow_constraint,
+	CN_IntegerMinLow_decode_ber,
+	CN_IntegerMinLow_encode_der,
+	CN_IntegerMinLow_decode_xer,
+	CN_IntegerMinLow_encode_xer,
+	CN_IntegerMinLow_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CN_IntegerMinLow_tags_1,
+	sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerMinLow_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
+		/sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
+	&asn_PER_CN_IntegerMinLow_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [NO-IntegerMinHigh] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [NO-IntegerMinHigh] >>> ***/
+
+typedef INTEGER_t	 NO_IntegerMinHigh_t;
+
+/*** <<< FUNC-DECLS [NO-IntegerMinHigh] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh;
+asn_struct_free_f NO_IntegerMinHigh_free;
+asn_struct_print_f NO_IntegerMinHigh_print;
+asn_constr_check_f NO_IntegerMinHigh_constraint;
+ber_type_decoder_f NO_IntegerMinHigh_decode_ber;
+der_type_encoder_f NO_IntegerMinHigh_encode_der;
+xer_type_decoder_f NO_IntegerMinHigh_decode_xer;
+xer_type_encoder_f NO_IntegerMinHigh_encode_xer;
+per_type_decoder_f NO_IntegerMinHigh_decode_uper;
+
+/*** <<< CODE [NO-IntegerMinHigh] >>> ***/
+
+int
+NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value <= 3000000000)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+NO_IntegerMinHigh_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+NO_IntegerMinHigh_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+NO_IntegerMinHigh_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerMinHigh_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+NO_IntegerMinHigh_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) {
+	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerMinHigh_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+NO_IntegerMinHigh_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) {
+	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerMinHigh_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [NO-IntegerMinHigh] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_NO_IntegerMinHigh_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }	/* (MIN..3000000000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
+	"NO-IntegerMinHigh",
+	"NO-IntegerMinHigh",
+	NO_IntegerMinHigh_free,
+	NO_IntegerMinHigh_print,
+	NO_IntegerMinHigh_constraint,
+	NO_IntegerMinHigh_decode_ber,
+	NO_IntegerMinHigh_encode_der,
+	NO_IntegerMinHigh_decode_xer,
+	NO_IntegerMinHigh_encode_xer,
+	NO_IntegerMinHigh_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_NO_IntegerMinHigh_tags_1,
+	sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerMinHigh_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
+	&asn_PER_NO_IntegerMinHigh_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [NO-IntegerLowHigh] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [NO-IntegerLowHigh] >>> ***/
+
+typedef INTEGER_t	 NO_IntegerLowHigh_t;
+
+/*** <<< FUNC-DECLS [NO-IntegerLowHigh] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh;
+asn_struct_free_f NO_IntegerLowHigh_free;
+asn_struct_print_f NO_IntegerLowHigh_print;
+asn_constr_check_f NO_IntegerLowHigh_constraint;
+ber_type_decoder_f NO_IntegerLowHigh_decode_ber;
+der_type_encoder_f NO_IntegerLowHigh_encode_der;
+xer_type_decoder_f NO_IntegerLowHigh_decode_xer;
+xer_type_encoder_f NO_IntegerLowHigh_encode_xer;
+per_type_decoder_f NO_IntegerLowHigh_decode_uper;
+
+/*** <<< CODE [NO-IntegerLowHigh] >>> ***/
+
+int
+NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 1 && value <= 3000000000)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+NO_IntegerLowHigh_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+NO_IntegerLowHigh_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+NO_IntegerLowHigh_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerLowHigh_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+NO_IntegerLowHigh_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) {
+	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerLowHigh_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+NO_IntegerLowHigh_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) {
+	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerLowHigh_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [NO-IntegerLowHigh] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_NO_IntegerLowHigh_constr_1 = {
+	{ APC_CONSTRAINED,	 32, -1,  1,  3000000000 }	/* (1..3000000000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
+	"NO-IntegerLowHigh",
+	"NO-IntegerLowHigh",
+	NO_IntegerLowHigh_free,
+	NO_IntegerLowHigh_print,
+	NO_IntegerLowHigh_constraint,
+	NO_IntegerLowHigh_decode_ber,
+	NO_IntegerLowHigh_encode_der,
+	NO_IntegerLowHigh_decode_xer,
+	NO_IntegerLowHigh_encode_xer,
+	NO_IntegerLowHigh_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_NO_IntegerLowHigh_tags_1,
+	sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerLowHigh_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
+	&asn_PER_NO_IntegerLowHigh_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [CN-IntegerLowMax] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [CN-IntegerLowMax] >>> ***/
+
+typedef INTEGER_t	 CN_IntegerLowMax_t;
+
+/*** <<< FUNC-DECLS [CN-IntegerLowMax] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax;
+asn_struct_free_f CN_IntegerLowMax_free;
+asn_struct_print_f CN_IntegerLowMax_print;
+asn_constr_check_f CN_IntegerLowMax_constraint;
+ber_type_decoder_f CN_IntegerLowMax_decode_ber;
+der_type_encoder_f CN_IntegerLowMax_encode_der;
+xer_type_decoder_f CN_IntegerLowMax_decode_xer;
+xer_type_encoder_f CN_IntegerLowMax_encode_xer;
+per_type_decoder_f CN_IntegerLowMax_decode_uper;
+
+/*** <<< CODE [CN-IntegerLowMax] >>> ***/
+
+int
+CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CN_IntegerLowMax_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+CN_IntegerLowMax_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CN_IntegerLowMax_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerLowMax_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CN_IntegerLowMax_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) {
+	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerLowMax_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CN_IntegerLowMax_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) {
+	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerLowMax_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [CN-IntegerLowMax] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_CN_IntegerLowMax_constr_1 = {
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  1,  0 }	/* (1..MAX) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax = {
+	"CN-IntegerLowMax",
+	"CN-IntegerLowMax",
+	CN_IntegerLowMax_free,
+	CN_IntegerLowMax_print,
+	CN_IntegerLowMax_constraint,
+	CN_IntegerLowMax_decode_ber,
+	CN_IntegerLowMax_encode_der,
+	CN_IntegerLowMax_decode_xer,
+	CN_IntegerLowMax_encode_xer,
+	CN_IntegerLowMax_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CN_IntegerLowMax_tags_1,
+	sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerLowMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
+		/sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
+	&asn_PER_CN_IntegerLowMax_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [NO-IntegerHighMax] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [NO-IntegerHighMax] >>> ***/
+
+typedef INTEGER_t	 NO_IntegerHighMax_t;
+
+/*** <<< FUNC-DECLS [NO-IntegerHighMax] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax;
+asn_struct_free_f NO_IntegerHighMax_free;
+asn_struct_print_f NO_IntegerHighMax_print;
+asn_constr_check_f NO_IntegerHighMax_constraint;
+ber_type_decoder_f NO_IntegerHighMax_decode_ber;
+der_type_encoder_f NO_IntegerHighMax_encode_der;
+xer_type_decoder_f NO_IntegerHighMax_decode_xer;
+xer_type_encoder_f NO_IntegerHighMax_encode_xer;
+per_type_decoder_f NO_IntegerHighMax_decode_uper;
+
+/*** <<< CODE [NO-IntegerHighMax] >>> ***/
+
+int
+NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 3000000000)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+NO_IntegerHighMax_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+NO_IntegerHighMax_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+NO_IntegerHighMax_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerHighMax_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+NO_IntegerHighMax_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) {
+	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerHighMax_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+NO_IntegerHighMax_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) {
+	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerHighMax_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [NO-IntegerHighMax] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_NO_IntegerHighMax_constr_1 = {
+	{ APC_SEMI_CONSTRAINED,	-1, -1,  3000000000,  0 }	/* (3000000000..MAX) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax = {
+	"NO-IntegerHighMax",
+	"NO-IntegerHighMax",
+	NO_IntegerHighMax_free,
+	NO_IntegerHighMax_print,
+	NO_IntegerHighMax_constraint,
+	NO_IntegerHighMax_decode_ber,
+	NO_IntegerHighMax_encode_der,
+	NO_IntegerHighMax_decode_xer,
+	NO_IntegerHighMax_encode_xer,
+	NO_IntegerHighMax_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_NO_IntegerHighMax_tags_1,
+	sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerHighMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
+	&asn_PER_NO_IntegerHighMax_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [NO-IntegerLowestMax] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [NO-IntegerLowestMax] >>> ***/
+
+typedef INTEGER_t	 NO_IntegerLowestMax_t;
+
+/*** <<< FUNC-DECLS [NO-IntegerLowestMax] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax;
+asn_struct_free_f NO_IntegerLowestMax_free;
+asn_struct_print_f NO_IntegerLowestMax_print;
+asn_constr_check_f NO_IntegerLowestMax_constraint;
+ber_type_decoder_f NO_IntegerLowestMax_decode_ber;
+der_type_encoder_f NO_IntegerLowestMax_encode_der;
+xer_type_decoder_f NO_IntegerLowestMax_decode_xer;
+xer_type_encoder_f NO_IntegerLowestMax_encode_xer;
+per_type_decoder_f NO_IntegerLowestMax_decode_uper;
+
+/*** <<< CODE [NO-IntegerLowestMax] >>> ***/
+
+int
+NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= -3000000000)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+NO_IntegerLowestMax_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+NO_IntegerLowestMax_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+NO_IntegerLowestMax_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerLowestMax_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+NO_IntegerLowestMax_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) {
+	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerLowestMax_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+NO_IntegerLowestMax_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) {
+	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerLowestMax_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [NO-IntegerLowestMax] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_NO_IntegerLowestMax_constr_1 = {
+	{ APC_SEMI_CONSTRAINED,	-1, -1, -3000000000,  0 }	/* (-3000000000..MAX) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
+	"NO-IntegerLowestMax",
+	"NO-IntegerLowestMax",
+	NO_IntegerLowestMax_free,
+	NO_IntegerLowestMax_print,
+	NO_IntegerLowestMax_constraint,
+	NO_IntegerLowestMax_decode_ber,
+	NO_IntegerLowestMax_encode_der,
+	NO_IntegerLowestMax_decode_xer,
+	NO_IntegerLowestMax_encode_xer,
+	NO_IntegerLowestMax_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_NO_IntegerLowestMax_tags_1,
+	sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerLowestMax_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
+		/sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
+	&asn_PER_NO_IntegerLowestMax_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [NO-IntegerOutRange] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [NO-IntegerOutRange] >>> ***/
+
+typedef INTEGER_t	 NO_IntegerOutRange_t;
+
+/*** <<< FUNC-DECLS [NO-IntegerOutRange] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange;
+asn_struct_free_f NO_IntegerOutRange_free;
+asn_struct_print_f NO_IntegerOutRange_print;
+asn_constr_check_f NO_IntegerOutRange_constraint;
+ber_type_decoder_f NO_IntegerOutRange_decode_ber;
+der_type_encoder_f NO_IntegerOutRange_encode_der;
+xer_type_decoder_f NO_IntegerOutRange_decode_xer;
+xer_type_encoder_f NO_IntegerOutRange_encode_xer;
+per_type_decoder_f NO_IntegerOutRange_decode_uper;
+
+/*** <<< CODE [NO-IntegerOutRange] >>> ***/
+
+int
+NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 3000000000 && value <= 3000000001)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+NO_IntegerOutRange_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+NO_IntegerOutRange_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+NO_IntegerOutRange_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerOutRange_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+NO_IntegerOutRange_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) {
+	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerOutRange_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+NO_IntegerOutRange_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) {
+	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerOutRange_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_NO_IntegerOutRange_constr_1 = {
+	{ APC_CONSTRAINED,	 1, -1,  3000000000,  3000000001 }	/* (3000000000..3000000001) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
+	"NO-IntegerOutRange",
+	"NO-IntegerOutRange",
+	NO_IntegerOutRange_free,
+	NO_IntegerOutRange_print,
+	NO_IntegerOutRange_constraint,
+	NO_IntegerOutRange_decode_ber,
+	NO_IntegerOutRange_encode_der,
+	NO_IntegerOutRange_decode_xer,
+	NO_IntegerOutRange_encode_xer,
+	NO_IntegerOutRange_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_NO_IntegerOutRange_tags_1,
+	sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerOutRange_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
+	&asn_PER_NO_IntegerOutRange_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [NO-IntegerOutValue] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [NO-IntegerOutValue] >>> ***/
+
+typedef INTEGER_t	 NO_IntegerOutValue_t;
+
+/*** <<< FUNC-DECLS [NO-IntegerOutValue] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue;
+asn_struct_free_f NO_IntegerOutValue_free;
+asn_struct_print_f NO_IntegerOutValue_print;
+asn_constr_check_f NO_IntegerOutValue_constraint;
+ber_type_decoder_f NO_IntegerOutValue_decode_ber;
+der_type_encoder_f NO_IntegerOutValue_encode_der;
+xer_type_decoder_f NO_IntegerOutValue_decode_xer;
+xer_type_encoder_f NO_IntegerOutValue_encode_xer;
+per_type_decoder_f NO_IntegerOutValue_decode_uper;
+
+/*** <<< CODE [NO-IntegerOutValue] >>> ***/
+
+int
+NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value == 3000000000)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+NO_IntegerOutValue_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+NO_IntegerOutValue_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+NO_IntegerOutValue_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerOutValue_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+NO_IntegerOutValue_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) {
+	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerOutValue_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+NO_IntegerOutValue_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) {
+	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerOutValue_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_NO_IntegerOutValue_constr_1 = {
+	{ APC_CONSTRAINED,	 0, -1,  3000000000,  3000000000 }	/* (3000000000..3000000000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
+	"NO-IntegerOutValue",
+	"NO-IntegerOutValue",
+	NO_IntegerOutValue_free,
+	NO_IntegerOutValue_print,
+	NO_IntegerOutValue_constraint,
+	NO_IntegerOutValue_decode_ber,
+	NO_IntegerOutValue_encode_der,
+	NO_IntegerOutValue_decode_xer,
+	NO_IntegerOutValue_encode_xer,
+	NO_IntegerOutValue_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_NO_IntegerOutValue_tags_1,
+	sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerOutValue_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
+		/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
+	&asn_PER_NO_IntegerOutValue_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [OK-IntegerInRange1] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [OK-IntegerInRange1] >>> ***/
+
+typedef long	 OK_IntegerInRange1_t;
+
+/*** <<< FUNC-DECLS [OK-IntegerInRange1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1;
+asn_struct_free_f OK_IntegerInRange1_free;
+asn_struct_print_f OK_IntegerInRange1_print;
+asn_constr_check_f OK_IntegerInRange1_constraint;
+ber_type_decoder_f OK_IntegerInRange1_decode_ber;
+der_type_encoder_f OK_IntegerInRange1_encode_der;
+xer_type_decoder_f OK_IntegerInRange1_decode_xer;
+xer_type_encoder_f OK_IntegerInRange1_encode_xer;
+per_type_decoder_f OK_IntegerInRange1_decode_uper;
+
+/*** <<< CODE [OK-IntegerInRange1] >>> ***/
+
+int
+OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= -100 && value <= 100)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+OK_IntegerInRange1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+OK_IntegerInRange1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+OK_IntegerInRange1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange1_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) {
+	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange1_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) {
+	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [OK-IntegerInRange1] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_OK_IntegerInRange1_constr_1 = {
+	{ APC_CONSTRAINED,	 8,  8, -100,  100 }	/* (-100..100) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1 = {
+	"OK-IntegerInRange1",
+	"OK-IntegerInRange1",
+	OK_IntegerInRange1_free,
+	OK_IntegerInRange1_print,
+	OK_IntegerInRange1_constraint,
+	OK_IntegerInRange1_decode_ber,
+	OK_IntegerInRange1_encode_der,
+	OK_IntegerInRange1_decode_xer,
+	OK_IntegerInRange1_encode_xer,
+	OK_IntegerInRange1_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_OK_IntegerInRange1_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
+	&asn_PER_OK_IntegerInRange1_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [OK-IntegerInRange2] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [OK-IntegerInRange2] >>> ***/
+
+typedef long	 OK_IntegerInRange2_t;
+
+/*** <<< FUNC-DECLS [OK-IntegerInRange2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2;
+asn_struct_free_f OK_IntegerInRange2_free;
+asn_struct_print_f OK_IntegerInRange2_print;
+asn_constr_check_f OK_IntegerInRange2_constraint;
+ber_type_decoder_f OK_IntegerInRange2_decode_ber;
+der_type_encoder_f OK_IntegerInRange2_encode_der;
+xer_type_decoder_f OK_IntegerInRange2_decode_xer;
+xer_type_encoder_f OK_IntegerInRange2_encode_xer;
+per_type_decoder_f OK_IntegerInRange2_decode_uper;
+
+/*** <<< CODE [OK-IntegerInRange2] >>> ***/
+
+int
+OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if(((value == -100) || (value == 100))) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+OK_IntegerInRange2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+OK_IntegerInRange2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+OK_IntegerInRange2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange2_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) {
+	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange2_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) {
+	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [OK-IntegerInRange2] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_OK_IntegerInRange2_constr_1 = {
+	{ APC_CONSTRAINED,	 8,  8, -100,  100 }	/* (-100..100) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2 = {
+	"OK-IntegerInRange2",
+	"OK-IntegerInRange2",
+	OK_IntegerInRange2_free,
+	OK_IntegerInRange2_print,
+	OK_IntegerInRange2_constraint,
+	OK_IntegerInRange2_decode_ber,
+	OK_IntegerInRange2_encode_der,
+	OK_IntegerInRange2_decode_xer,
+	OK_IntegerInRange2_encode_xer,
+	OK_IntegerInRange2_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_OK_IntegerInRange2_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
+	&asn_PER_OK_IntegerInRange2_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [OK-IntegerInRange3] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [OK-IntegerInRange3] >>> ***/
+
+typedef long	 OK_IntegerInRange3_t;
+
+/*** <<< FUNC-DECLS [OK-IntegerInRange3] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3;
+asn_struct_free_f OK_IntegerInRange3_free;
+asn_struct_print_f OK_IntegerInRange3_print;
+asn_constr_check_f OK_IntegerInRange3_constraint;
+ber_type_decoder_f OK_IntegerInRange3_decode_ber;
+der_type_encoder_f OK_IntegerInRange3_encode_der;
+xer_type_decoder_f OK_IntegerInRange3_decode_xer;
+xer_type_encoder_f OK_IntegerInRange3_encode_xer;
+per_type_decoder_f OK_IntegerInRange3_decode_uper;
+
+/*** <<< CODE [OK-IntegerInRange3] >>> ***/
+
+int
+OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= -2147483648 && value <= 2147483647)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+OK_IntegerInRange3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+OK_IntegerInRange3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+OK_IntegerInRange3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange3_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) {
+	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange3_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) {
+	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [OK-IntegerInRange3] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_OK_IntegerInRange3_constr_1 = {
+	{ APC_CONSTRAINED,	 32, -1, -2147483648,  2147483647 }	/* (-2147483648..2147483647) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3 = {
+	"OK-IntegerInRange3",
+	"OK-IntegerInRange3",
+	OK_IntegerInRange3_free,
+	OK_IntegerInRange3_print,
+	OK_IntegerInRange3_constraint,
+	OK_IntegerInRange3_decode_ber,
+	OK_IntegerInRange3_encode_der,
+	OK_IntegerInRange3_decode_xer,
+	OK_IntegerInRange3_encode_xer,
+	OK_IntegerInRange3_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_OK_IntegerInRange3_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
+	&asn_PER_OK_IntegerInRange3_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [OK-IntegerInRange4] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [OK-IntegerInRange4] >>> ***/
+
+typedef long	 OK_IntegerInRange4_t;
+
+/*** <<< FUNC-DECLS [OK-IntegerInRange4] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4;
+asn_struct_free_f OK_IntegerInRange4_free;
+asn_struct_print_f OK_IntegerInRange4_print;
+asn_constr_check_f OK_IntegerInRange4_constraint;
+ber_type_decoder_f OK_IntegerInRange4_decode_ber;
+der_type_encoder_f OK_IntegerInRange4_encode_der;
+xer_type_decoder_f OK_IntegerInRange4_decode_xer;
+xer_type_encoder_f OK_IntegerInRange4_encode_xer;
+per_type_decoder_f OK_IntegerInRange4_decode_uper;
+
+/*** <<< CODE [OK-IntegerInRange4] >>> ***/
+
+int
+OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if(((value == -2147483648) || (value == 2147483647))) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+OK_IntegerInRange4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+OK_IntegerInRange4_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+OK_IntegerInRange4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange4_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange4_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) {
+	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange4_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange4_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) {
+	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [OK-IntegerInRange4] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_OK_IntegerInRange4_constr_1 = {
+	{ APC_CONSTRAINED,	 32, -1, -2147483648,  2147483647 }	/* (-2147483648..2147483647) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4 = {
+	"OK-IntegerInRange4",
+	"OK-IntegerInRange4",
+	OK_IntegerInRange4_free,
+	OK_IntegerInRange4_print,
+	OK_IntegerInRange4_constraint,
+	OK_IntegerInRange4_decode_ber,
+	OK_IntegerInRange4_encode_der,
+	OK_IntegerInRange4_decode_xer,
+	OK_IntegerInRange4_encode_xer,
+	OK_IntegerInRange4_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_OK_IntegerInRange4_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
+	&asn_PER_OK_IntegerInRange4_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [OK-IntegerInRange5] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [OK-IntegerInRange5] >>> ***/
+
+typedef INTEGER_t	 OK_IntegerInRange5_t;
+
+/*** <<< FUNC-DECLS [OK-IntegerInRange5] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5;
+asn_struct_free_f OK_IntegerInRange5_free;
+asn_struct_print_f OK_IntegerInRange5_print;
+asn_constr_check_f OK_IntegerInRange5_constraint;
+ber_type_decoder_f OK_IntegerInRange5_decode_ber;
+der_type_encoder_f OK_IntegerInRange5_encode_der;
+xer_type_decoder_f OK_IntegerInRange5_decode_xer;
+xer_type_encoder_f OK_IntegerInRange5_encode_xer;
+per_type_decoder_f OK_IntegerInRange5_decode_uper;
+
+/*** <<< CODE [OK-IntegerInRange5] >>> ***/
+
+int
+OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(((value == -2147483648) || (value == 2147483647))) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+OK_IntegerInRange5_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+OK_IntegerInRange5_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+OK_IntegerInRange5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange5_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange5_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) {
+	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange5_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+OK_IntegerInRange5_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) {
+	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+OK_IntegerInRange5_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [OK-IntegerInRange5] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_OK_IntegerInRange5_constr_1 = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  32, -1, -2147483648,  2147483647 }	/* (-2147483648..2147483647,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
+	"OK-IntegerInRange5",
+	"OK-IntegerInRange5",
+	OK_IntegerInRange5_free,
+	OK_IntegerInRange5_print,
+	OK_IntegerInRange5_constraint,
+	OK_IntegerInRange5_decode_ber,
+	OK_IntegerInRange5_encode_der,
+	OK_IntegerInRange5_decode_xer,
+	OK_IntegerInRange5_encode_xer,
+	OK_IntegerInRange5_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_OK_IntegerInRange5_tags_1,
+	sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
+	asn_DEF_OK_IntegerInRange5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
+		/sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
+	&asn_PER_OK_IntegerInRange5_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [NO-IntegerInRange6] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< TYPE-DECLS [NO-IntegerInRange6] >>> ***/
+
+typedef INTEGER_t	 NO_IntegerInRange6_t;
+
+/*** <<< FUNC-DECLS [NO-IntegerInRange6] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6;
+asn_struct_free_f NO_IntegerInRange6_free;
+asn_struct_print_f NO_IntegerInRange6_print;
+asn_constr_check_f NO_IntegerInRange6_constraint;
+ber_type_decoder_f NO_IntegerInRange6_decode_ber;
+der_type_encoder_f NO_IntegerInRange6_encode_der;
+xer_type_decoder_f NO_IntegerInRange6_decode_xer;
+xer_type_encoder_f NO_IntegerInRange6_encode_xer;
+per_type_decoder_f NO_IntegerInRange6_decode_uper;
+
+/*** <<< CODE [NO-IntegerInRange6] >>> ***/
+
+int
+NO_IntegerInRange6_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 0 && value <= 4294967295)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+NO_IntegerInRange6_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+NO_IntegerInRange6_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+NO_IntegerInRange6_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerInRange6_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+NO_IntegerInRange6_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) {
+	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerInRange6_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+NO_IntegerInRange6_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) {
+	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerInRange6_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static asn_per_constraints_t asn_PER_NO_IntegerInRange6_constr_1 = {
+	{ APC_CONSTRAINED,	 32, -1,  0,  4294967295 }	/* (0..4294967295) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
+	"NO-IntegerInRange6",
+	"NO-IntegerInRange6",
+	NO_IntegerInRange6_free,
+	NO_IntegerInRange6_print,
+	NO_IntegerInRange6_constraint,
+	NO_IntegerInRange6_decode_ber,
+	NO_IntegerInRange6_encode_der,
+	NO_IntegerInRange6_decode_xer,
+	NO_IntegerInRange6_encode_xer,
+	NO_IntegerInRange6_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_NO_IntegerInRange6_tags_1,
+	sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
+		/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerInRange6_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
+		/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
+	&asn_PER_NO_IntegerInRange6_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [CN-IntegerEnumerated1] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< DEPS [CN-IntegerEnumerated1] >>> ***/
+
+typedef enum CN_IntegerEnumerated1 {
+	CN_IntegerEnumerated1_a	= 1,
+	CN_IntegerEnumerated1_b	= 2
+} CN_IntegerEnumerated1_e;
+
+/*** <<< TYPE-DECLS [CN-IntegerEnumerated1] >>> ***/
+
+typedef INTEGER_t	 CN_IntegerEnumerated1_t;
+
+/*** <<< FUNC-DECLS [CN-IntegerEnumerated1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1;
+asn_struct_free_f CN_IntegerEnumerated1_free;
+asn_struct_print_f CN_IntegerEnumerated1_print;
+asn_constr_check_f CN_IntegerEnumerated1_constraint;
+ber_type_decoder_f CN_IntegerEnumerated1_decode_ber;
+der_type_encoder_f CN_IntegerEnumerated1_encode_der;
+xer_type_decoder_f CN_IntegerEnumerated1_decode_xer;
+xer_type_encoder_f CN_IntegerEnumerated1_encode_xer;
+per_type_decoder_f CN_IntegerEnumerated1_decode_uper;
+
+/*** <<< CODE [CN-IntegerEnumerated1] >>> ***/
+
+int
+CN_IntegerEnumerated1_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
+CN_IntegerEnumerated1_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+CN_IntegerEnumerated1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CN_IntegerEnumerated1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerEnumerated1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CN_IntegerEnumerated1_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) {
+	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerEnumerated1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CN_IntegerEnumerated1_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) {
+	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CN_IntegerEnumerated1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [CN-IntegerEnumerated1] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1 = {
+	"CN-IntegerEnumerated1",
+	"CN-IntegerEnumerated1",
+	CN_IntegerEnumerated1_free,
+	CN_IntegerEnumerated1_print,
+	CN_IntegerEnumerated1_constraint,
+	CN_IntegerEnumerated1_decode_ber,
+	CN_IntegerEnumerated1_encode_der,
+	CN_IntegerEnumerated1_decode_xer,
+	CN_IntegerEnumerated1_encode_xer,
+	CN_IntegerEnumerated1_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CN_IntegerEnumerated1_tags_1,
+	sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
+		/sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
+	asn_DEF_CN_IntegerEnumerated1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
+		/sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [NO-IntegerEnumerated2] >>> ***/
+
+#include <INTEGER.h>
+
+/*** <<< DEPS [NO-IntegerEnumerated2] >>> ***/
+
+typedef enum NO_IntegerEnumerated2 {
+	NO_IntegerEnumerated2_a	= 1,
+	NO_IntegerEnumerated2_b	= 3000000000
+} NO_IntegerEnumerated2_e;
+
+/*** <<< TYPE-DECLS [NO-IntegerEnumerated2] >>> ***/
+
+typedef INTEGER_t	 NO_IntegerEnumerated2_t;
+
+/*** <<< FUNC-DECLS [NO-IntegerEnumerated2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2;
+asn_struct_free_f NO_IntegerEnumerated2_free;
+asn_struct_print_f NO_IntegerEnumerated2_print;
+asn_constr_check_f NO_IntegerEnumerated2_constraint;
+ber_type_decoder_f NO_IntegerEnumerated2_decode_ber;
+der_type_encoder_f NO_IntegerEnumerated2_encode_der;
+xer_type_decoder_f NO_IntegerEnumerated2_decode_xer;
+xer_type_encoder_f NO_IntegerEnumerated2_encode_xer;
+per_type_decoder_f NO_IntegerEnumerated2_decode_uper;
+
+/*** <<< CODE [NO-IntegerEnumerated2] >>> ***/
+
+int
+NO_IntegerEnumerated2_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
+NO_IntegerEnumerated2_1_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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+NO_IntegerEnumerated2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+NO_IntegerEnumerated2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerEnumerated2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+NO_IntegerEnumerated2_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) {
+	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerEnumerated2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+NO_IntegerEnumerated2_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) {
+	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+NO_IntegerEnumerated2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+
+/*** <<< STAT-DEFS [NO-IntegerEnumerated2] >>> ***/
+
+static ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2 = {
+	"NO-IntegerEnumerated2",
+	"NO-IntegerEnumerated2",
+	NO_IntegerEnumerated2_free,
+	NO_IntegerEnumerated2_print,
+	NO_IntegerEnumerated2_constraint,
+	NO_IntegerEnumerated2_decode_ber,
+	NO_IntegerEnumerated2_encode_der,
+	NO_IntegerEnumerated2_decode_xer,
+	NO_IntegerEnumerated2_encode_xer,
+	NO_IntegerEnumerated2_decode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_NO_IntegerEnumerated2_tags_1,
+	sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
+		/sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
+	asn_DEF_NO_IntegerEnumerated2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
+		/sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
diff --git a/tests/91-cond-int-blessSize-OK.asn1.-Pfbless-SIZE b/tests/91-cond-int-blessSize-OK.asn1.-Pfbless-SIZE
index 5fe0bd3..1164e41 100644
--- a/tests/91-cond-int-blessSize-OK.asn1.-Pfbless-SIZE
+++ b/tests/91-cond-int-blessSize-OK.asn1.-Pfbless-SIZE
@@ -53,6 +53,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -105,7 +108,7 @@
 
 /*** <<< STAT-DEFS [OK-Integer1] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_Integer1_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_Integer1_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_Integer1 = {
@@ -118,13 +121,15 @@
 	OK_Integer1_encode_der,
 	OK_Integer1_decode_xer,
 	OK_Integer1_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_Integer1_1_tags,
-	sizeof(asn_DEF_OK_Integer1_1_tags)
-		/sizeof(asn_DEF_OK_Integer1_1_tags[0]), /* 1 */
-	asn_DEF_OK_Integer1_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_Integer1_1_tags)
-		/sizeof(asn_DEF_OK_Integer1_1_tags[0]), /* 1 */
+	asn_DEF_OK_Integer1_tags_1,
+	sizeof(asn_DEF_OK_Integer1_tags_1)
+		/sizeof(asn_DEF_OK_Integer1_tags_1[0]), /* 1 */
+	asn_DEF_OK_Integer1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_Integer1_tags_1)
+		/sizeof(asn_DEF_OK_Integer1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -184,6 +189,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -236,7 +244,7 @@
 
 /*** <<< STAT-DEFS [OK-Integer2] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_Integer2_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_Integer2_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_Integer2 = {
@@ -249,13 +257,15 @@
 	OK_Integer2_encode_der,
 	OK_Integer2_decode_xer,
 	OK_Integer2_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_Integer2_1_tags,
-	sizeof(asn_DEF_OK_Integer2_1_tags)
-		/sizeof(asn_DEF_OK_Integer2_1_tags[0]), /* 1 */
-	asn_DEF_OK_Integer2_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_Integer2_1_tags)
-		/sizeof(asn_DEF_OK_Integer2_1_tags[0]), /* 1 */
+	asn_DEF_OK_Integer2_tags_1,
+	sizeof(asn_DEF_OK_Integer2_tags_1)
+		/sizeof(asn_DEF_OK_Integer2_tags_1[0]), /* 1 */
+	asn_DEF_OK_Integer2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_Integer2_tags_1)
+		/sizeof(asn_DEF_OK_Integer2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -315,6 +325,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -367,7 +380,7 @@
 
 /*** <<< STAT-DEFS [OK-Integer3] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_Integer3_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_Integer3_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_Integer3 = {
@@ -380,13 +393,15 @@
 	OK_Integer3_encode_der,
 	OK_Integer3_decode_xer,
 	OK_Integer3_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_Integer3_1_tags,
-	sizeof(asn_DEF_OK_Integer3_1_tags)
-		/sizeof(asn_DEF_OK_Integer3_1_tags[0]), /* 1 */
-	asn_DEF_OK_Integer3_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_Integer3_1_tags)
-		/sizeof(asn_DEF_OK_Integer3_1_tags[0]), /* 1 */
+	asn_DEF_OK_Integer3_tags_1,
+	sizeof(asn_DEF_OK_Integer3_tags_1)
+		/sizeof(asn_DEF_OK_Integer3_tags_1[0]), /* 1 */
+	asn_DEF_OK_Integer3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_Integer3_tags_1)
+		/sizeof(asn_DEF_OK_Integer3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -446,6 +461,9 @@
 	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
 	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
 	td->elements       = asn_DEF_NativeInteger.elements;
 	td->elements_count = asn_DEF_NativeInteger.elements_count;
 	td->specifics      = asn_DEF_NativeInteger.specifics;
@@ -498,7 +516,7 @@
 
 /*** <<< STAT-DEFS [OK-Integer4] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_OK_Integer4_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OK_Integer4_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_OK_Integer4 = {
@@ -511,13 +529,15 @@
 	OK_Integer4_encode_der,
 	OK_Integer4_decode_xer,
 	OK_Integer4_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OK_Integer4_1_tags,
-	sizeof(asn_DEF_OK_Integer4_1_tags)
-		/sizeof(asn_DEF_OK_Integer4_1_tags[0]), /* 1 */
-	asn_DEF_OK_Integer4_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OK_Integer4_1_tags)
-		/sizeof(asn_DEF_OK_Integer4_1_tags[0]), /* 1 */
+	asn_DEF_OK_Integer4_tags_1,
+	sizeof(asn_DEF_OK_Integer4_tags_1)
+		/sizeof(asn_DEF_OK_Integer4_tags_1[0]), /* 1 */
+	asn_DEF_OK_Integer4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OK_Integer4_tags_1)
+		/sizeof(asn_DEF_OK_Integer4_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
@@ -578,6 +598,9 @@
 	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->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
 	td->elements_count = asn_DEF_INTEGER.elements_count;
 	td->specifics      = asn_DEF_INTEGER.specifics;
@@ -630,7 +653,7 @@
 
 /*** <<< STAT-DEFS [NO-Integer5] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_NO_Integer5_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_NO_Integer5_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_NO_Integer5 = {
@@ -643,13 +666,15 @@
 	NO_Integer5_encode_der,
 	NO_Integer5_decode_xer,
 	NO_Integer5_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_NO_Integer5_1_tags,
-	sizeof(asn_DEF_NO_Integer5_1_tags)
-		/sizeof(asn_DEF_NO_Integer5_1_tags[0]), /* 1 */
-	asn_DEF_NO_Integer5_1_tags,	/* Same as above */
-	sizeof(asn_DEF_NO_Integer5_1_tags)
-		/sizeof(asn_DEF_NO_Integer5_1_tags[0]), /* 1 */
+	asn_DEF_NO_Integer5_tags_1,
+	sizeof(asn_DEF_NO_Integer5_tags_1)
+		/sizeof(asn_DEF_NO_Integer5_tags_1[0]), /* 1 */
+	asn_DEF_NO_Integer5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NO_Integer5_tags_1)
+		/sizeof(asn_DEF_NO_Integer5_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* No members */
 	0	/* No specifics */
 };
diff --git a/tests/92-circular-loops-OK.asn1.-P b/tests/92-circular-loops-OK.asn1.-P
index a45b9bf..5e161af 100644
--- a/tests/92-circular-loops-OK.asn1.-P
+++ b/tests/92-circular-loops-OK.asn1.-P
@@ -52,6 +52,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_Choice1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ch1"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Everything, ch2),
@@ -59,6 +61,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_Choice2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ch2"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Everything, ch3),
@@ -66,6 +70,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_Choice3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ch3"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, set),
@@ -73,6 +79,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, a),
@@ -80,6 +88,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Alpha,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, b),
@@ -87,6 +97,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Beta,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, g),
@@ -94,6 +106,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Gamma,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "g"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, ot),
@@ -101,6 +115,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_OneTwo,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ot"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, tt),
@@ -108,6 +124,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_TwoThree,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "tt"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, to),
@@ -115,13 +133,15 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_ThreeOne,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "to"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Everything_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Everything_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Everything_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Everything_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ch1 at 15 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ch2 at 16 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ch3 at 17 */
@@ -133,11 +153,12 @@
     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* tt at 23 */
     { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* to at 25 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Everything_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1 = {
 	sizeof(struct Everything),
 	offsetof(struct Everything, _asn_ctx),
-	asn_MAP_Everything_1_tag2el,
+	asn_MAP_Everything_tag2el_1,
 	10,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -151,16 +172,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Everything_1_tags,
-	sizeof(asn_DEF_Everything_1_tags)
-		/sizeof(asn_DEF_Everything_1_tags[0]), /* 1 */
-	asn_DEF_Everything_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Everything_1_tags)
-		/sizeof(asn_DEF_Everything_1_tags[0]), /* 1 */
+	asn_DEF_Everything_tags_1,
+	sizeof(asn_DEF_Everything_tags_1)
+		/sizeof(asn_DEF_Everything_tags_1[0]), /* 1 */
+	asn_DEF_Everything_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Everything_tags_1)
+		/sizeof(asn_DEF_Everything_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Everything_1,
 	10,	/* Elements count */
-	&asn_SPC_Everything_1_specs	/* Additional specs */
+	&asn_SPC_Everything_specs_1	/* Additional specs */
 };
 
 
@@ -214,6 +237,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "something"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice1, choice.some2),
@@ -221,21 +246,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "some2"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice1_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice1_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* something at 29 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some2 at 32 */
 };
-static asn_CHOICE_specifics_t asn_SPC_Choice1_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
 	sizeof(struct Choice1),
 	offsetof(struct Choice1, _asn_ctx),
 	offsetof(struct Choice1, present),
 	sizeof(((struct Choice1 *)0)->present),
-	asn_MAP_Choice1_1_tag2el,
+	asn_MAP_Choice1_tag2el_1,
 	2,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice1 = {
 	"Choice1",
@@ -247,14 +275,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice1_1,
 	2,	/* Elements count */
-	&asn_SPC_Choice1_1_specs	/* Additional specs */
+	&asn_SPC_Choice1_specs_1	/* Additional specs */
 };
 
 
@@ -309,6 +339,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_TypeRef,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "typeref"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice2, choice.some3),
@@ -316,21 +348,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "some3"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice2_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice2_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* typeref at 35 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some3 at 38 */
 };
-static asn_CHOICE_specifics_t asn_SPC_Choice2_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
 	sizeof(struct Choice2),
 	offsetof(struct Choice2, _asn_ctx),
 	offsetof(struct Choice2, present),
 	sizeof(((struct Choice2 *)0)->present),
-	asn_MAP_Choice2_1_tag2el,
+	asn_MAP_Choice2_tag2el_1,
 	2,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice2 = {
 	"Choice2",
@@ -342,14 +377,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice2_1,
 	2,	/* Elements count */
-	&asn_SPC_Choice2_1_specs	/* Additional specs */
+	&asn_SPC_Choice2_specs_1	/* Additional specs */
 };
 
 
@@ -415,21 +452,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "aa"
 		},
 };
-static ber_tlv_tag_t asn_DEF_a_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_a_tags_2[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_a_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_a_tag2el_2[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* aa at 43 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_a_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_a_specs_2 = {
 	sizeof(struct a),
 	offsetof(struct a, _asn_ctx),
-	asn_MAP_a_2_tag2el,
+	asn_MAP_a_tag2el_2,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -444,16 +484,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_a_2_tags,
-	sizeof(asn_DEF_a_2_tags)
-		/sizeof(asn_DEF_a_2_tags[0]) - 1, /* 1 */
-	asn_DEF_a_2_tags,	/* Same as above */
-	sizeof(asn_DEF_a_2_tags)
-		/sizeof(asn_DEF_a_2_tags[0]), /* 2 */
+	asn_DEF_a_tags_2,
+	sizeof(asn_DEF_a_tags_2)
+		/sizeof(asn_DEF_a_tags_2[0]) - 1, /* 1 */
+	asn_DEF_a_tags_2,	/* Same as above */
+	sizeof(asn_DEF_a_tags_2)
+		/sizeof(asn_DEF_a_tags_2[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_a_2,
 	1,	/* Elements count */
-	&asn_SPC_a_2_specs	/* Additional specs */
+	&asn_SPC_a_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_c_5[] = {
@@ -462,14 +504,16 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Choice3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_c_5_tags[] = {
+static ber_tlv_tag_t asn_DEF_c_tags_5[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_c_5_specs = {
+static asn_SET_OF_specifics_t asn_SPC_c_specs_5 = {
 	sizeof(struct c),
 	offsetof(struct c, _asn_ctx),
 	2,	/* XER encoding is XMLValueList */
@@ -485,16 +529,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_c_5_tags,
-	sizeof(asn_DEF_c_5_tags)
-		/sizeof(asn_DEF_c_5_tags[0]) - 1, /* 1 */
-	asn_DEF_c_5_tags,	/* Same as above */
-	sizeof(asn_DEF_c_5_tags)
-		/sizeof(asn_DEF_c_5_tags[0]), /* 2 */
+	asn_DEF_c_tags_5,
+	sizeof(asn_DEF_c_tags_5)
+		/sizeof(asn_DEF_c_tags_5[0]) - 1, /* 1 */
+	asn_DEF_c_tags_5,	/* Same as above */
+	sizeof(asn_DEF_c_tags_5)
+		/sizeof(asn_DEF_c_tags_5[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_c_5,
 	1,	/* Single element */
-	&asn_SPC_c_5_specs	/* Additional specs */
+	&asn_SPC_c_specs_5	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Choice3_1[] = {
@@ -503,6 +549,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_a_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice3, choice.b),
@@ -510,6 +558,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Choice3, choice.c),
@@ -517,22 +567,25 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_c_5,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "c"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice3_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice3_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 43 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* b at 44 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* c at 46 */
 };
-static asn_CHOICE_specifics_t asn_SPC_Choice3_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1 = {
 	sizeof(struct Choice3),
 	offsetof(struct Choice3, _asn_ctx),
 	offsetof(struct Choice3, present),
 	sizeof(((struct Choice3 *)0)->present),
-	asn_MAP_Choice3_1_tag2el,
+	asn_MAP_Choice3_tag2el_1,
 	3,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice3 = {
 	"Choice3",
@@ -544,14 +597,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice3_1,
 	3,	/* Elements count */
-	&asn_SPC_Choice3_1_specs	/* Additional specs */
+	&asn_SPC_Choice3_specs_1	/* Additional specs */
 };
 
 
@@ -606,6 +661,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "int"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Member, set),
@@ -613,6 +670,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Member, seq),
@@ -620,6 +679,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "seq"
 		},
 	{ ATF_POINTER, 2, offsetof(struct Member, set2),
@@ -627,6 +688,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set2"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Member, set3),
@@ -634,31 +697,34 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set3"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Member_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Member_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Member_tag2el_2[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* int at 49 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* set at 50 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* seq at 51 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* set2 at 52 */
     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* set3 at 55 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Member_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Member_specs_2 = {
 	sizeof(struct Member),
 	offsetof(struct Member, _asn_ctx),
-	asn_MAP_Member_2_tag2el,
+	asn_MAP_Member_tag2el_2,
 	5,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	3,	/* Start extensions */
 	6	/* Stop extensions */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_Member_2 = {
-	"",
-	"",
+	"SEQUENCE",
+	"SEQUENCE",
 	SEQUENCE_free,
 	SEQUENCE_print,
 	SEQUENCE_constraint,
@@ -666,16 +732,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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 */
+	asn_DEF_Member_tags_2,
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	asn_DEF_Member_tags_2,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Member_2,
 	5,	/* Elements count */
-	&asn_SPC_Member_2_specs	/* Additional specs */
+	&asn_SPC_Member_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Set_1[] = {
@@ -684,13 +752,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Member_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Set_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Set_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_Set_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Set_specs_1 = {
 	sizeof(struct Set),
 	offsetof(struct Set, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -705,16 +775,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Set_tags_1,
+	sizeof(asn_DEF_Set_tags_1)
+		/sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
+	asn_DEF_Set_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Set_tags_1)
+		/sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Set_1,
 	1,	/* Single element */
-	&asn_SPC_Set_1_specs	/* Additional specs */
+	&asn_SPC_Set_specs_1	/* Additional specs */
 };
 
 
@@ -761,6 +833,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_POINTER, 3, offsetof(struct Sequence, seq),
@@ -768,6 +842,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "seq"
 		},
 	{ ATF_POINTER, 2, offsetof(struct Sequence, b),
@@ -775,6 +851,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Sequence, set),
@@ -782,23 +860,26 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Sequence_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Sequence_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 58 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* seq at 59 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* b at 61 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* set at 62 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Sequence_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
 	sizeof(struct Sequence),
 	offsetof(struct Sequence, _asn_ctx),
-	asn_MAP_Sequence_1_tag2el,
+	asn_MAP_Sequence_tag2el_1,
 	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	1,	/* Start extensions */
 	5	/* Stop extensions */
 };
@@ -812,16 +893,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Sequence_tags_1,
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	asn_DEF_Sequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Sequence_1,
 	4,	/* Elements count */
-	&asn_SPC_Sequence_1_specs	/* Additional specs */
+	&asn_SPC_Sequence_specs_1	/* Additional specs */
 };
 
 
@@ -866,6 +949,9 @@
 	td->der_encoder    = asn_DEF_Sequence.der_encoder;
 	td->xer_decoder    = asn_DEF_Sequence.xer_decoder;
 	td->xer_encoder    = asn_DEF_Sequence.xer_encoder;
+	td->uper_decoder   = asn_DEF_Sequence.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Sequence.per_constraints;
 	td->elements       = asn_DEF_Sequence.elements;
 	td->elements_count = asn_DEF_Sequence.elements_count;
 	td->specifics      = asn_DEF_Sequence.specifics;
@@ -918,7 +1004,7 @@
 
 /*** <<< STAT-DEFS [TypeRef] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_TypeRef_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_TypeRef_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_TypeRef = {
@@ -931,13 +1017,15 @@
 	TypeRef_encode_der,
 	TypeRef_decode_xer,
 	TypeRef_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_TypeRef_1_tags,
-	sizeof(asn_DEF_TypeRef_1_tags)
-		/sizeof(asn_DEF_TypeRef_1_tags[0]), /* 1 */
-	asn_DEF_TypeRef_1_tags,	/* Same as above */
-	sizeof(asn_DEF_TypeRef_1_tags)
-		/sizeof(asn_DEF_TypeRef_1_tags[0]), /* 1 */
+	asn_DEF_TypeRef_tags_1,
+	sizeof(asn_DEF_TypeRef_tags_1)
+		/sizeof(asn_DEF_TypeRef_tags_1[0]), /* 1 */
+	asn_DEF_TypeRef_tags_1,	/* Same as above */
+	sizeof(asn_DEF_TypeRef_tags_1)
+		/sizeof(asn_DEF_TypeRef_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -982,21 +1070,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Beta,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_b_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_b_tags_3[] = {
 	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_b_3_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_b_tag2el_3[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* b at 70 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_b_3_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_b_specs_3 = {
 	sizeof(struct b),
 	offsetof(struct b, _asn_ctx),
-	asn_MAP_b_3_tag2el,
+	asn_MAP_b_tag2el_3,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -1011,16 +1102,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_b_3_tags,
-	sizeof(asn_DEF_b_3_tags)
-		/sizeof(asn_DEF_b_3_tags[0]) - 1, /* 1 */
-	asn_DEF_b_3_tags,	/* Same as above */
-	sizeof(asn_DEF_b_3_tags)
-		/sizeof(asn_DEF_b_3_tags[0]), /* 2 */
+	asn_DEF_b_tags_3,
+	sizeof(asn_DEF_b_tags_3)
+		/sizeof(asn_DEF_b_tags_3[0]) - 1, /* 1 */
+	asn_DEF_b_tags_3,	/* Same as above */
+	sizeof(asn_DEF_b_tags_3)
+		/sizeof(asn_DEF_b_tags_3[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_b_3,
 	1,	/* Elements count */
-	&asn_SPC_b_3_specs	/* Additional specs */
+	&asn_SPC_b_specs_3	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Alpha_1[] = {
@@ -1029,6 +1122,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Beta,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Alpha, b),
@@ -1036,21 +1131,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_b_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Alpha_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Alpha_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Alpha_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Alpha_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 68 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b at 70 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Alpha_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1 = {
 	sizeof(struct Alpha),
 	offsetof(struct Alpha, _asn_ctx),
-	asn_MAP_Alpha_1_tag2el,
+	asn_MAP_Alpha_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -1064,16 +1162,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Alpha_1_tags,
-	sizeof(asn_DEF_Alpha_1_tags)
-		/sizeof(asn_DEF_Alpha_1_tags[0]), /* 1 */
-	asn_DEF_Alpha_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Alpha_1_tags)
-		/sizeof(asn_DEF_Alpha_1_tags[0]), /* 1 */
+	asn_DEF_Alpha_tags_1,
+	sizeof(asn_DEF_Alpha_tags_1)
+		/sizeof(asn_DEF_Alpha_tags_1[0]), /* 1 */
+	asn_DEF_Alpha_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Alpha_tags_1)
+		/sizeof(asn_DEF_Alpha_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Alpha_1,
 	2,	/* Elements count */
-	&asn_SPC_Alpha_1_specs	/* Additional specs */
+	&asn_SPC_Alpha_specs_1	/* Additional specs */
 };
 
 
@@ -1113,6 +1213,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Alpha,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Beta, g),
@@ -1120,21 +1222,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Gamma,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "g"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Beta_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Beta_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Beta_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Beta_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* b at 75 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* g at 76 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Beta_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1 = {
 	sizeof(struct Beta),
 	offsetof(struct Beta, _asn_ctx),
-	asn_MAP_Beta_1_tag2el,
+	asn_MAP_Beta_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -1148,16 +1253,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Beta_1_tags,
-	sizeof(asn_DEF_Beta_1_tags)
-		/sizeof(asn_DEF_Beta_1_tags[0]), /* 1 */
-	asn_DEF_Beta_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Beta_1_tags)
-		/sizeof(asn_DEF_Beta_1_tags[0]), /* 1 */
+	asn_DEF_Beta_tags_1,
+	sizeof(asn_DEF_Beta_tags_1)
+		/sizeof(asn_DEF_Beta_tags_1[0]), /* 1 */
+	asn_DEF_Beta_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Beta_tags_1)
+		/sizeof(asn_DEF_Beta_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Beta_1,
 	2,	/* Elements count */
-	&asn_SPC_Beta_1_specs	/* Additional specs */
+	&asn_SPC_Beta_specs_1	/* Additional specs */
 };
 
 
@@ -1200,6 +1307,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_TwoThree,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "o"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Gamma, a),
@@ -1207,6 +1316,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Alpha,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Gamma, b),
@@ -1214,22 +1325,25 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Beta,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Gamma_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Gamma_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Gamma_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Gamma_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* o at 80 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* a at 81 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* b at 83 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Gamma_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1 = {
 	sizeof(struct Gamma),
 	offsetof(struct Gamma, _asn_ctx),
-	asn_MAP_Gamma_1_tag2el,
+	asn_MAP_Gamma_tag2el_1,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -1243,16 +1357,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Gamma_1_tags,
-	sizeof(asn_DEF_Gamma_1_tags)
-		/sizeof(asn_DEF_Gamma_1_tags[0]), /* 1 */
-	asn_DEF_Gamma_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Gamma_1_tags)
-		/sizeof(asn_DEF_Gamma_1_tags[0]), /* 1 */
+	asn_DEF_Gamma_tags_1,
+	sizeof(asn_DEF_Gamma_tags_1)
+		/sizeof(asn_DEF_Gamma_tags_1[0]), /* 1 */
+	asn_DEF_Gamma_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Gamma_tags_1)
+		/sizeof(asn_DEF_Gamma_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Gamma_1,
 	3,	/* Elements count */
-	&asn_SPC_Gamma_1_specs	/* Additional specs */
+	&asn_SPC_Gamma_specs_1	/* Additional specs */
 };
 
 
@@ -1303,28 +1419,30 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_TwoThree,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m12"
 		},
 };
-static ber_tlv_tag_t asn_DEF_OneTwo_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OneTwo_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_OneTwo_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_OneTwo_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* m12 at 86 */
 };
-static uint8_t asn_MAP_OneTwo_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_OneTwo_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_SPC_OneTwo_1_specs = {
+static asn_SET_specifics_t asn_SPC_OneTwo_specs_1 = {
 	sizeof(struct OneTwo),
 	offsetof(struct OneTwo, _asn_ctx),
 	offsetof(struct OneTwo, _presence_map),
-	asn_MAP_OneTwo_1_tag2el,
+	asn_MAP_OneTwo_tag2el_1,
 	1,	/* Count of tags in the map */
-	asn_MAP_OneTwo_1_tag2el,	/* Same as above */
+	asn_MAP_OneTwo_tag2el_1,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_OneTwo_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_OneTwo_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_OneTwo = {
 	"OneTwo",
@@ -1336,16 +1454,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OneTwo_1_tags,
-	sizeof(asn_DEF_OneTwo_1_tags)
-		/sizeof(asn_DEF_OneTwo_1_tags[0]), /* 1 */
-	asn_DEF_OneTwo_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OneTwo_1_tags)
-		/sizeof(asn_DEF_OneTwo_1_tags[0]), /* 1 */
+	asn_DEF_OneTwo_tags_1,
+	sizeof(asn_DEF_OneTwo_tags_1)
+		/sizeof(asn_DEF_OneTwo_tags_1[0]), /* 1 */
+	asn_DEF_OneTwo_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OneTwo_tags_1)
+		/sizeof(asn_DEF_OneTwo_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_OneTwo_1,
 	1,	/* Elements count */
-	&asn_SPC_OneTwo_1_specs	/* Additional specs */
+	&asn_SPC_OneTwo_specs_1	/* Additional specs */
 };
 
 
@@ -1396,28 +1516,30 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_ThreeOne,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m23"
 		},
 };
-static ber_tlv_tag_t asn_DEF_TwoThree_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_TwoThree_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_TwoThree_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_TwoThree_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* m23 at 87 */
 };
-static uint8_t asn_MAP_TwoThree_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_TwoThree_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_SPC_TwoThree_1_specs = {
+static asn_SET_specifics_t asn_SPC_TwoThree_specs_1 = {
 	sizeof(struct TwoThree),
 	offsetof(struct TwoThree, _asn_ctx),
 	offsetof(struct TwoThree, _presence_map),
-	asn_MAP_TwoThree_1_tag2el,
+	asn_MAP_TwoThree_tag2el_1,
 	1,	/* Count of tags in the map */
-	asn_MAP_TwoThree_1_tag2el,	/* Same as above */
+	asn_MAP_TwoThree_tag2el_1,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_TwoThree_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_TwoThree_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_TwoThree = {
 	"TwoThree",
@@ -1429,16 +1551,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_TwoThree_1_tags,
-	sizeof(asn_DEF_TwoThree_1_tags)
-		/sizeof(asn_DEF_TwoThree_1_tags[0]), /* 1 */
-	asn_DEF_TwoThree_1_tags,	/* Same as above */
-	sizeof(asn_DEF_TwoThree_1_tags)
-		/sizeof(asn_DEF_TwoThree_1_tags[0]), /* 1 */
+	asn_DEF_TwoThree_tags_1,
+	sizeof(asn_DEF_TwoThree_tags_1)
+		/sizeof(asn_DEF_TwoThree_tags_1[0]), /* 1 */
+	asn_DEF_TwoThree_tags_1,	/* Same as above */
+	sizeof(asn_DEF_TwoThree_tags_1)
+		/sizeof(asn_DEF_TwoThree_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_TwoThree_1,
 	1,	/* Elements count */
-	&asn_SPC_TwoThree_1_specs	/* Additional specs */
+	&asn_SPC_TwoThree_specs_1	/* Additional specs */
 };
 
 
@@ -1493,6 +1617,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_OneTwo,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m31"
 		},
 	{ ATF_POINTER, 0, offsetof(struct ThreeOne, g),
@@ -1500,29 +1626,31 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Gamma,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "g"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ThreeOne_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_ThreeOne_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_ThreeOne_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ThreeOne_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* m31 at 88 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* g at 88 */
 };
-static uint8_t asn_MAP_ThreeOne_1_mmap[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_ThreeOne_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (1 << 6)
 };
-static asn_SET_specifics_t asn_SPC_ThreeOne_1_specs = {
+static asn_SET_specifics_t asn_SPC_ThreeOne_specs_1 = {
 	sizeof(struct ThreeOne),
 	offsetof(struct ThreeOne, _asn_ctx),
 	offsetof(struct ThreeOne, _presence_map),
-	asn_MAP_ThreeOne_1_tag2el,
+	asn_MAP_ThreeOne_tag2el_1,
 	2,	/* Count of tags in the map */
-	asn_MAP_ThreeOne_1_tag2el,	/* Same as above */
+	asn_MAP_ThreeOne_tag2el_1,	/* Same as above */
 	2,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_ThreeOne_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_ThreeOne_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_ThreeOne = {
 	"ThreeOne",
@@ -1534,15 +1662,17 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ThreeOne_1_tags,
-	sizeof(asn_DEF_ThreeOne_1_tags)
-		/sizeof(asn_DEF_ThreeOne_1_tags[0]), /* 1 */
-	asn_DEF_ThreeOne_1_tags,	/* Same as above */
-	sizeof(asn_DEF_ThreeOne_1_tags)
-		/sizeof(asn_DEF_ThreeOne_1_tags[0]), /* 1 */
+	asn_DEF_ThreeOne_tags_1,
+	sizeof(asn_DEF_ThreeOne_tags_1)
+		/sizeof(asn_DEF_ThreeOne_tags_1[0]), /* 1 */
+	asn_DEF_ThreeOne_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ThreeOne_tags_1)
+		/sizeof(asn_DEF_ThreeOne_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_ThreeOne_1,
 	2,	/* Elements count */
-	&asn_SPC_ThreeOne_1_specs	/* Additional specs */
+	&asn_SPC_ThreeOne_specs_1	/* Additional specs */
 };
 
diff --git a/tests/92-circular-loops-OK.asn1.-Pfindirect-choice b/tests/92-circular-loops-OK.asn1.-Pfindirect-choice
index 391ca91..7f0c385 100644
--- a/tests/92-circular-loops-OK.asn1.-Pfindirect-choice
+++ b/tests/92-circular-loops-OK.asn1.-Pfindirect-choice
@@ -52,6 +52,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_Choice1,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ch1"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Everything, ch2),
@@ -59,6 +61,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_Choice2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ch2"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Everything, ch3),
@@ -66,6 +70,8 @@
 		.tag_mode = +1,	/* EXPLICIT tag at current level */
 		.type = &asn_DEF_Choice3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ch3"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, set),
@@ -73,6 +79,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, a),
@@ -80,6 +88,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Alpha,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, b),
@@ -87,6 +97,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Beta,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, g),
@@ -94,6 +106,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Gamma,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "g"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, ot),
@@ -101,6 +115,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_OneTwo,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ot"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, tt),
@@ -108,6 +124,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_TwoThree,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "tt"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Everything, to),
@@ -115,13 +133,15 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_ThreeOne,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "to"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Everything_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Everything_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Everything_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Everything_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ch1 at 15 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ch2 at 16 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ch3 at 17 */
@@ -133,11 +153,12 @@
     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* tt at 23 */
     { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* to at 25 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Everything_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1 = {
 	sizeof(struct Everything),
 	offsetof(struct Everything, _asn_ctx),
-	asn_MAP_Everything_1_tag2el,
+	asn_MAP_Everything_tag2el_1,
 	10,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -151,16 +172,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Everything_1_tags,
-	sizeof(asn_DEF_Everything_1_tags)
-		/sizeof(asn_DEF_Everything_1_tags[0]), /* 1 */
-	asn_DEF_Everything_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Everything_1_tags)
-		/sizeof(asn_DEF_Everything_1_tags[0]), /* 1 */
+	asn_DEF_Everything_tags_1,
+	sizeof(asn_DEF_Everything_tags_1)
+		/sizeof(asn_DEF_Everything_tags_1[0]), /* 1 */
+	asn_DEF_Everything_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Everything_tags_1)
+		/sizeof(asn_DEF_Everything_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Everything_1,
 	10,	/* Elements count */
-	&asn_SPC_Everything_1_specs	/* Additional specs */
+	&asn_SPC_Everything_specs_1	/* Additional specs */
 };
 
 
@@ -214,6 +237,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "something"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice1, choice.some2),
@@ -221,21 +246,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "some2"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice1_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice1_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* something at 29 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some2 at 32 */
 };
-static asn_CHOICE_specifics_t asn_SPC_Choice1_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
 	sizeof(struct Choice1),
 	offsetof(struct Choice1, _asn_ctx),
 	offsetof(struct Choice1, present),
 	sizeof(((struct Choice1 *)0)->present),
-	asn_MAP_Choice1_1_tag2el,
+	asn_MAP_Choice1_tag2el_1,
 	2,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice1 = {
 	"Choice1",
@@ -247,14 +275,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice1_1,
 	2,	/* Elements count */
-	&asn_SPC_Choice1_1_specs	/* Additional specs */
+	&asn_SPC_Choice1_specs_1	/* Additional specs */
 };
 
 
@@ -310,6 +340,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_TypeRef,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "typeref"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice2, choice.some3),
@@ -317,21 +349,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "some3"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice2_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice2_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* typeref at 35 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some3 at 38 */
 };
-static asn_CHOICE_specifics_t asn_SPC_Choice2_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
 	sizeof(struct Choice2),
 	offsetof(struct Choice2, _asn_ctx),
 	offsetof(struct Choice2, present),
 	sizeof(((struct Choice2 *)0)->present),
-	asn_MAP_Choice2_1_tag2el,
+	asn_MAP_Choice2_tag2el_1,
 	2,	/* Count of tags in the map */
-	1	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = 1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice2 = {
 	"Choice2",
@@ -343,14 +378,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice2_1,
 	2,	/* Elements count */
-	&asn_SPC_Choice2_1_specs	/* Additional specs */
+	&asn_SPC_Choice2_specs_1	/* Additional specs */
 };
 
 
@@ -416,21 +453,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "aa"
 		},
 };
-static ber_tlv_tag_t asn_DEF_a_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_a_tags_2[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_a_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_a_tag2el_2[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* aa at 43 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_a_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_a_specs_2 = {
 	sizeof(struct a),
 	offsetof(struct a, _asn_ctx),
-	asn_MAP_a_2_tag2el,
+	asn_MAP_a_tag2el_2,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -445,16 +485,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_a_2_tags,
-	sizeof(asn_DEF_a_2_tags)
-		/sizeof(asn_DEF_a_2_tags[0]) - 1, /* 1 */
-	asn_DEF_a_2_tags,	/* Same as above */
-	sizeof(asn_DEF_a_2_tags)
-		/sizeof(asn_DEF_a_2_tags[0]), /* 2 */
+	asn_DEF_a_tags_2,
+	sizeof(asn_DEF_a_tags_2)
+		/sizeof(asn_DEF_a_tags_2[0]) - 1, /* 1 */
+	asn_DEF_a_tags_2,	/* Same as above */
+	sizeof(asn_DEF_a_tags_2)
+		/sizeof(asn_DEF_a_tags_2[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_a_2,
 	1,	/* Elements count */
-	&asn_SPC_a_2_specs	/* Additional specs */
+	&asn_SPC_a_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_c_5[] = {
@@ -463,14 +505,16 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Choice3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_c_5_tags[] = {
+static ber_tlv_tag_t asn_DEF_c_tags_5[] = {
 	(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_c_5_specs = {
+static asn_SET_OF_specifics_t asn_SPC_c_specs_5 = {
 	sizeof(struct c),
 	offsetof(struct c, _asn_ctx),
 	2,	/* XER encoding is XMLValueList */
@@ -486,16 +530,18 @@
 	SEQUENCE_OF_encode_der,
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_c_5_tags,
-	sizeof(asn_DEF_c_5_tags)
-		/sizeof(asn_DEF_c_5_tags[0]) - 1, /* 1 */
-	asn_DEF_c_5_tags,	/* Same as above */
-	sizeof(asn_DEF_c_5_tags)
-		/sizeof(asn_DEF_c_5_tags[0]), /* 2 */
+	asn_DEF_c_tags_5,
+	sizeof(asn_DEF_c_tags_5)
+		/sizeof(asn_DEF_c_tags_5[0]) - 1, /* 1 */
+	asn_DEF_c_tags_5,	/* Same as above */
+	sizeof(asn_DEF_c_tags_5)
+		/sizeof(asn_DEF_c_tags_5[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_c_5,
 	1,	/* Single element */
-	&asn_SPC_c_5_specs	/* Additional specs */
+	&asn_SPC_c_specs_5	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Choice3_1[] = {
@@ -504,6 +550,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_a_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice3, choice.b),
@@ -511,6 +559,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Everything,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice3, choice.c),
@@ -518,22 +568,25 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_c_5,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "c"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice3_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice3_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 43 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* b at 44 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* c at 46 */
 };
-static asn_CHOICE_specifics_t asn_SPC_Choice3_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1 = {
 	sizeof(struct Choice3),
 	offsetof(struct Choice3, _asn_ctx),
 	offsetof(struct Choice3, present),
 	sizeof(((struct Choice3 *)0)->present),
-	asn_MAP_Choice3_1_tag2el,
+	asn_MAP_Choice3_tag2el_1,
 	3,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice3 = {
 	"Choice3",
@@ -545,14 +598,16 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice3_1,
 	3,	/* Elements count */
-	&asn_SPC_Choice3_1_specs	/* Additional specs */
+	&asn_SPC_Choice3_specs_1	/* Additional specs */
 };
 
 
@@ -607,6 +662,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "int"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Member, set),
@@ -614,6 +671,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Member, seq),
@@ -621,6 +680,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "seq"
 		},
 	{ ATF_POINTER, 2, offsetof(struct Member, set2),
@@ -628,6 +689,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set2"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Member, set3),
@@ -635,31 +698,34 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set3"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Member_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Member_2_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Member_tag2el_2[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* int at 49 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* set at 50 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* seq at 51 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* set2 at 52 */
     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* set3 at 55 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Member_2_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Member_specs_2 = {
 	sizeof(struct Member),
 	offsetof(struct Member, _asn_ctx),
-	asn_MAP_Member_2_tag2el,
+	asn_MAP_Member_tag2el_2,
 	5,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	3,	/* Start extensions */
 	6	/* Stop extensions */
 };
 static /* Use -fall-defs-global to expose */
 asn_TYPE_descriptor_t asn_DEF_Member_2 = {
-	"",
-	"",
+	"SEQUENCE",
+	"SEQUENCE",
 	SEQUENCE_free,
 	SEQUENCE_print,
 	SEQUENCE_constraint,
@@ -667,16 +733,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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 */
+	asn_DEF_Member_tags_2,
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	asn_DEF_Member_tags_2,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Member_2,
 	5,	/* Elements count */
-	&asn_SPC_Member_2_specs	/* Additional specs */
+	&asn_SPC_Member_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Set_1[] = {
@@ -685,13 +753,15 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_Member_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_Set_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Set_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_Set_1_specs = {
+static asn_SET_OF_specifics_t asn_SPC_Set_specs_1 = {
 	sizeof(struct Set),
 	offsetof(struct Set, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -706,16 +776,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Set_tags_1,
+	sizeof(asn_DEF_Set_tags_1)
+		/sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
+	asn_DEF_Set_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Set_tags_1)
+		/sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Set_1,
 	1,	/* Single element */
-	&asn_SPC_Set_1_specs	/* Additional specs */
+	&asn_SPC_Set_specs_1	/* Additional specs */
 };
 
 
@@ -762,6 +834,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_POINTER, 3, offsetof(struct Sequence, seq),
@@ -769,6 +843,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "seq"
 		},
 	{ ATF_POINTER, 2, offsetof(struct Sequence, b),
@@ -776,6 +852,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Sequence, set),
@@ -783,23 +861,26 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Set,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "set"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Sequence_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Sequence_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 58 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* seq at 59 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* b at 61 */
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* set at 62 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Sequence_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
 	sizeof(struct Sequence),
 	offsetof(struct Sequence, _asn_ctx),
-	asn_MAP_Sequence_1_tag2el,
+	asn_MAP_Sequence_tag2el_1,
 	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	1,	/* Start extensions */
 	5	/* Stop extensions */
 };
@@ -813,16 +894,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Sequence_tags_1,
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	asn_DEF_Sequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Sequence_1,
 	4,	/* Elements count */
-	&asn_SPC_Sequence_1_specs	/* Additional specs */
+	&asn_SPC_Sequence_specs_1	/* Additional specs */
 };
 
 
@@ -867,6 +950,9 @@
 	td->der_encoder    = asn_DEF_Sequence.der_encoder;
 	td->xer_decoder    = asn_DEF_Sequence.xer_decoder;
 	td->xer_encoder    = asn_DEF_Sequence.xer_encoder;
+	td->uper_decoder   = asn_DEF_Sequence.uper_decoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Sequence.per_constraints;
 	td->elements       = asn_DEF_Sequence.elements;
 	td->elements_count = asn_DEF_Sequence.elements_count;
 	td->specifics      = asn_DEF_Sequence.specifics;
@@ -919,7 +1005,7 @@
 
 /*** <<< STAT-DEFS [TypeRef] >>> ***/
 
-static ber_tlv_tag_t asn_DEF_TypeRef_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_TypeRef_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_TypeRef = {
@@ -932,13 +1018,15 @@
 	TypeRef_encode_der,
 	TypeRef_decode_xer,
 	TypeRef_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_TypeRef_1_tags,
-	sizeof(asn_DEF_TypeRef_1_tags)
-		/sizeof(asn_DEF_TypeRef_1_tags[0]), /* 1 */
-	asn_DEF_TypeRef_1_tags,	/* Same as above */
-	sizeof(asn_DEF_TypeRef_1_tags)
-		/sizeof(asn_DEF_TypeRef_1_tags[0]), /* 1 */
+	asn_DEF_TypeRef_tags_1,
+	sizeof(asn_DEF_TypeRef_tags_1)
+		/sizeof(asn_DEF_TypeRef_tags_1[0]), /* 1 */
+	asn_DEF_TypeRef_tags_1,	/* Same as above */
+	sizeof(asn_DEF_TypeRef_tags_1)
+		/sizeof(asn_DEF_TypeRef_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	0, 0,	/* Defined elsewhere */
 	0	/* No specifics */
 };
@@ -983,21 +1071,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Beta,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_b_3_tags[] = {
+static ber_tlv_tag_t asn_DEF_b_tags_3[] = {
 	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_b_3_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_b_tag2el_3[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* b at 70 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_b_3_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_b_specs_3 = {
 	sizeof(struct b),
 	offsetof(struct b, _asn_ctx),
-	asn_MAP_b_3_tag2el,
+	asn_MAP_b_tag2el_3,
 	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -1012,16 +1103,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_b_3_tags,
-	sizeof(asn_DEF_b_3_tags)
-		/sizeof(asn_DEF_b_3_tags[0]) - 1, /* 1 */
-	asn_DEF_b_3_tags,	/* Same as above */
-	sizeof(asn_DEF_b_3_tags)
-		/sizeof(asn_DEF_b_3_tags[0]), /* 2 */
+	asn_DEF_b_tags_3,
+	sizeof(asn_DEF_b_tags_3)
+		/sizeof(asn_DEF_b_tags_3[0]) - 1, /* 1 */
+	asn_DEF_b_tags_3,	/* Same as above */
+	sizeof(asn_DEF_b_tags_3)
+		/sizeof(asn_DEF_b_tags_3[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_b_3,
 	1,	/* Elements count */
-	&asn_SPC_b_3_specs	/* Additional specs */
+	&asn_SPC_b_specs_3	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Alpha_1[] = {
@@ -1030,6 +1123,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Beta,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Alpha, b),
@@ -1037,21 +1132,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_b_3,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Alpha_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Alpha_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Alpha_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Alpha_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 68 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b at 70 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Alpha_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1 = {
 	sizeof(struct Alpha),
 	offsetof(struct Alpha, _asn_ctx),
-	asn_MAP_Alpha_1_tag2el,
+	asn_MAP_Alpha_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -1065,16 +1163,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Alpha_1_tags,
-	sizeof(asn_DEF_Alpha_1_tags)
-		/sizeof(asn_DEF_Alpha_1_tags[0]), /* 1 */
-	asn_DEF_Alpha_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Alpha_1_tags)
-		/sizeof(asn_DEF_Alpha_1_tags[0]), /* 1 */
+	asn_DEF_Alpha_tags_1,
+	sizeof(asn_DEF_Alpha_tags_1)
+		/sizeof(asn_DEF_Alpha_tags_1[0]), /* 1 */
+	asn_DEF_Alpha_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Alpha_tags_1)
+		/sizeof(asn_DEF_Alpha_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Alpha_1,
 	2,	/* Elements count */
-	&asn_SPC_Alpha_1_specs	/* Additional specs */
+	&asn_SPC_Alpha_specs_1	/* Additional specs */
 };
 
 
@@ -1114,6 +1214,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Alpha,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 	{ ATF_POINTER, 1, offsetof(struct Beta, g),
@@ -1121,21 +1223,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Gamma,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "g"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Beta_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Beta_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Beta_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Beta_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* b at 75 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* g at 76 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Beta_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1 = {
 	sizeof(struct Beta),
 	offsetof(struct Beta, _asn_ctx),
-	asn_MAP_Beta_1_tag2el,
+	asn_MAP_Beta_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -1149,16 +1254,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Beta_1_tags,
-	sizeof(asn_DEF_Beta_1_tags)
-		/sizeof(asn_DEF_Beta_1_tags[0]), /* 1 */
-	asn_DEF_Beta_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Beta_1_tags)
-		/sizeof(asn_DEF_Beta_1_tags[0]), /* 1 */
+	asn_DEF_Beta_tags_1,
+	sizeof(asn_DEF_Beta_tags_1)
+		/sizeof(asn_DEF_Beta_tags_1[0]), /* 1 */
+	asn_DEF_Beta_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Beta_tags_1)
+		/sizeof(asn_DEF_Beta_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Beta_1,
 	2,	/* Elements count */
-	&asn_SPC_Beta_1_specs	/* Additional specs */
+	&asn_SPC_Beta_specs_1	/* Additional specs */
 };
 
 
@@ -1201,6 +1308,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_TwoThree,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "o"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Gamma, a),
@@ -1208,6 +1317,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Alpha,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "a"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Gamma, b),
@@ -1215,22 +1326,25 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Beta,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "b"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Gamma_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Gamma_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Gamma_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Gamma_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* o at 80 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* a at 81 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* b at 83 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Gamma_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1 = {
 	sizeof(struct Gamma),
 	offsetof(struct Gamma, _asn_ctx),
-	asn_MAP_Gamma_1_tag2el,
+	asn_MAP_Gamma_tag2el_1,
 	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -1244,16 +1358,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Gamma_1_tags,
-	sizeof(asn_DEF_Gamma_1_tags)
-		/sizeof(asn_DEF_Gamma_1_tags[0]), /* 1 */
-	asn_DEF_Gamma_1_tags,	/* Same as above */
-	sizeof(asn_DEF_Gamma_1_tags)
-		/sizeof(asn_DEF_Gamma_1_tags[0]), /* 1 */
+	asn_DEF_Gamma_tags_1,
+	sizeof(asn_DEF_Gamma_tags_1)
+		/sizeof(asn_DEF_Gamma_tags_1[0]), /* 1 */
+	asn_DEF_Gamma_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Gamma_tags_1)
+		/sizeof(asn_DEF_Gamma_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Gamma_1,
 	3,	/* Elements count */
-	&asn_SPC_Gamma_1_specs	/* Additional specs */
+	&asn_SPC_Gamma_specs_1	/* Additional specs */
 };
 
 
@@ -1304,28 +1420,30 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_TwoThree,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m12"
 		},
 };
-static ber_tlv_tag_t asn_DEF_OneTwo_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_OneTwo_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_OneTwo_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_OneTwo_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* m12 at 86 */
 };
-static uint8_t asn_MAP_OneTwo_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_OneTwo_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_SPC_OneTwo_1_specs = {
+static asn_SET_specifics_t asn_SPC_OneTwo_specs_1 = {
 	sizeof(struct OneTwo),
 	offsetof(struct OneTwo, _asn_ctx),
 	offsetof(struct OneTwo, _presence_map),
-	asn_MAP_OneTwo_1_tag2el,
+	asn_MAP_OneTwo_tag2el_1,
 	1,	/* Count of tags in the map */
-	asn_MAP_OneTwo_1_tag2el,	/* Same as above */
+	asn_MAP_OneTwo_tag2el_1,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_OneTwo_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_OneTwo_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_OneTwo = {
 	"OneTwo",
@@ -1337,16 +1455,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_OneTwo_1_tags,
-	sizeof(asn_DEF_OneTwo_1_tags)
-		/sizeof(asn_DEF_OneTwo_1_tags[0]), /* 1 */
-	asn_DEF_OneTwo_1_tags,	/* Same as above */
-	sizeof(asn_DEF_OneTwo_1_tags)
-		/sizeof(asn_DEF_OneTwo_1_tags[0]), /* 1 */
+	asn_DEF_OneTwo_tags_1,
+	sizeof(asn_DEF_OneTwo_tags_1)
+		/sizeof(asn_DEF_OneTwo_tags_1[0]), /* 1 */
+	asn_DEF_OneTwo_tags_1,	/* Same as above */
+	sizeof(asn_DEF_OneTwo_tags_1)
+		/sizeof(asn_DEF_OneTwo_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_OneTwo_1,
 	1,	/* Elements count */
-	&asn_SPC_OneTwo_1_specs	/* Additional specs */
+	&asn_SPC_OneTwo_specs_1	/* Additional specs */
 };
 
 
@@ -1397,28 +1517,30 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_ThreeOne,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m23"
 		},
 };
-static ber_tlv_tag_t asn_DEF_TwoThree_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_TwoThree_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_TwoThree_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_TwoThree_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* m23 at 87 */
 };
-static uint8_t asn_MAP_TwoThree_1_mmap[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_TwoThree_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7)
 };
-static asn_SET_specifics_t asn_SPC_TwoThree_1_specs = {
+static asn_SET_specifics_t asn_SPC_TwoThree_specs_1 = {
 	sizeof(struct TwoThree),
 	offsetof(struct TwoThree, _asn_ctx),
 	offsetof(struct TwoThree, _presence_map),
-	asn_MAP_TwoThree_1_tag2el,
+	asn_MAP_TwoThree_tag2el_1,
 	1,	/* Count of tags in the map */
-	asn_MAP_TwoThree_1_tag2el,	/* Same as above */
+	asn_MAP_TwoThree_tag2el_1,	/* Same as above */
 	1,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_TwoThree_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_TwoThree_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_TwoThree = {
 	"TwoThree",
@@ -1430,16 +1552,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_TwoThree_1_tags,
-	sizeof(asn_DEF_TwoThree_1_tags)
-		/sizeof(asn_DEF_TwoThree_1_tags[0]), /* 1 */
-	asn_DEF_TwoThree_1_tags,	/* Same as above */
-	sizeof(asn_DEF_TwoThree_1_tags)
-		/sizeof(asn_DEF_TwoThree_1_tags[0]), /* 1 */
+	asn_DEF_TwoThree_tags_1,
+	sizeof(asn_DEF_TwoThree_tags_1)
+		/sizeof(asn_DEF_TwoThree_tags_1[0]), /* 1 */
+	asn_DEF_TwoThree_tags_1,	/* Same as above */
+	sizeof(asn_DEF_TwoThree_tags_1)
+		/sizeof(asn_DEF_TwoThree_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_TwoThree_1,
 	1,	/* Elements count */
-	&asn_SPC_TwoThree_1_specs	/* Additional specs */
+	&asn_SPC_TwoThree_specs_1	/* Additional specs */
 };
 
 
@@ -1494,6 +1618,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_OneTwo,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m31"
 		},
 	{ ATF_POINTER, 0, offsetof(struct ThreeOne, g),
@@ -1501,29 +1627,31 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Gamma,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "g"
 		},
 };
-static ber_tlv_tag_t asn_DEF_ThreeOne_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_ThreeOne_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_ThreeOne_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_ThreeOne_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* m31 at 88 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* g at 88 */
 };
-static uint8_t asn_MAP_ThreeOne_1_mmap[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_ThreeOne_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (1 << 6)
 };
-static asn_SET_specifics_t asn_SPC_ThreeOne_1_specs = {
+static asn_SET_specifics_t asn_SPC_ThreeOne_specs_1 = {
 	sizeof(struct ThreeOne),
 	offsetof(struct ThreeOne, _asn_ctx),
 	offsetof(struct ThreeOne, _presence_map),
-	asn_MAP_ThreeOne_1_tag2el,
+	asn_MAP_ThreeOne_tag2el_1,
 	2,	/* Count of tags in the map */
-	asn_MAP_ThreeOne_1_tag2el,	/* Same as above */
+	asn_MAP_ThreeOne_tag2el_1,	/* Same as above */
 	2,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_ThreeOne_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_ThreeOne_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_ThreeOne = {
 	"ThreeOne",
@@ -1535,15 +1663,17 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_ThreeOne_1_tags,
-	sizeof(asn_DEF_ThreeOne_1_tags)
-		/sizeof(asn_DEF_ThreeOne_1_tags[0]), /* 1 */
-	asn_DEF_ThreeOne_1_tags,	/* Same as above */
-	sizeof(asn_DEF_ThreeOne_1_tags)
-		/sizeof(asn_DEF_ThreeOne_1_tags[0]), /* 1 */
+	asn_DEF_ThreeOne_tags_1,
+	sizeof(asn_DEF_ThreeOne_tags_1)
+		/sizeof(asn_DEF_ThreeOne_tags_1[0]), /* 1 */
+	asn_DEF_ThreeOne_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ThreeOne_tags_1)
+		/sizeof(asn_DEF_ThreeOne_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_ThreeOne_1,
 	2,	/* Elements count */
-	&asn_SPC_ThreeOne_1_specs	/* Additional specs */
+	&asn_SPC_ThreeOne_specs_1	/* Additional specs */
 };
 
diff --git a/tests/93-asn1c-controls-OK.asn1.-P b/tests/93-asn1c-controls-OK.asn1.-P
index f2d5fe3..0be9a2c 100644
--- a/tests/93-asn1c-controls-OK.asn1.-P
+++ b/tests/93-asn1c-controls-OK.asn1.-P
@@ -26,6 +26,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ainl"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Sequence, aptr),
@@ -33,21 +35,24 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "aptr"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Sequence_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Sequence_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ainl at 15 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* aptr at 18 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Sequence_1_specs = {
+static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
 	sizeof(struct Sequence),
 	offsetof(struct Sequence, _asn_ctx),
-	asn_MAP_Sequence_1_tag2el,
+	asn_MAP_Sequence_tag2el_1,
 	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
@@ -61,16 +66,18 @@
 	SEQUENCE_encode_der,
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Sequence_tags_1,
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	asn_DEF_Sequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Sequence_tags_1)
+		/sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Sequence_1,
 	2,	/* Elements count */
-	&asn_SPC_Sequence_1_specs	/* Additional specs */
+	&asn_SPC_Sequence_specs_1	/* Additional specs */
 };
 
 
@@ -124,6 +131,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ainl"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Set, aptr),
@@ -131,29 +140,31 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "aptr"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Set_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_Set_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Set_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Set_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ainl at 21 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* aptr at 24 */
 };
-static uint8_t asn_MAP_Set_1_mmap[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_Set_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (1 << 6)
 };
-static asn_SET_specifics_t asn_SPC_Set_1_specs = {
+static asn_SET_specifics_t asn_SPC_Set_specs_1 = {
 	sizeof(struct Set),
 	offsetof(struct Set, _asn_ctx),
 	offsetof(struct Set, _presence_map),
-	asn_MAP_Set_1_tag2el,
+	asn_MAP_Set_tag2el_1,
 	2,	/* Count of tags in the map */
-	asn_MAP_Set_1_tag2el,	/* Same as above */
+	asn_MAP_Set_tag2el_1,	/* Same as above */
 	2,	/* Count of tags in the CXER map */
 	0,	/* Whether extensible */
-	(unsigned int *)asn_MAP_Set_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_Set_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_Set = {
 	"Set",
@@ -165,16 +176,18 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	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_DEF_Set_tags_1,
+	sizeof(asn_DEF_Set_tags_1)
+		/sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
+	asn_DEF_Set_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Set_tags_1)
+		/sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_Set_1,
 	2,	/* Elements count */
-	&asn_SPC_Set_1_specs	/* Additional specs */
+	&asn_SPC_Set_specs_1	/* Additional specs */
 };
 
 
@@ -234,14 +247,16 @@
 		.tag_mode = 0,
 		.type = &asn_DEF_INTEGER,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = ""
 		},
 };
-static ber_tlv_tag_t asn_DEF_setof_2_tags[] = {
+static ber_tlv_tag_t asn_DEF_setof_tags_2[] = {
 	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_setof_2_specs = {
+static asn_SET_OF_specifics_t asn_SPC_setof_specs_2 = {
 	sizeof(struct setof),
 	offsetof(struct setof, _asn_ctx),
 	0,	/* XER encoding is XMLDelimitedItemList */
@@ -257,16 +272,18 @@
 	SET_OF_encode_der,
 	SET_OF_decode_xer,
 	SET_OF_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_setof_2_tags,
-	sizeof(asn_DEF_setof_2_tags)
-		/sizeof(asn_DEF_setof_2_tags[0]) - 1, /* 1 */
-	asn_DEF_setof_2_tags,	/* Same as above */
-	sizeof(asn_DEF_setof_2_tags)
-		/sizeof(asn_DEF_setof_2_tags[0]), /* 2 */
+	asn_DEF_setof_tags_2,
+	sizeof(asn_DEF_setof_tags_2)
+		/sizeof(asn_DEF_setof_tags_2[0]) - 1, /* 1 */
+	asn_DEF_setof_tags_2,	/* Same as above */
+	sizeof(asn_DEF_setof_tags_2)
+		/sizeof(asn_DEF_setof_tags_2[0]), /* 2 */
+	0,	/* No PER visible constraints */
 	asn_MBR_setof_2,
 	1,	/* Single element */
-	&asn_SPC_setof_2_specs	/* Additional specs */
+	&asn_SPC_setof_specs_2	/* Additional specs */
 };
 
 static asn_TYPE_member_t asn_MBR_Choice_1[] = {
@@ -275,6 +292,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_setof_2,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "setof"
 		},
 	{ ATF_POINTER, 0, offsetof(struct Choice, choice.aptr),
@@ -282,6 +301,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "aptr"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.ainl),
@@ -289,22 +310,25 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_Sequence,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "ainl"
 		},
 };
-static asn_TYPE_tag2member_t asn_MAP_Choice_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_Choice_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* setof at 28 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* aptr at 30 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* ainl at 32 */
 };
-static asn_CHOICE_specifics_t asn_SPC_Choice_1_specs = {
+static asn_CHOICE_specifics_t asn_SPC_Choice_specs_1 = {
 	sizeof(struct Choice),
 	offsetof(struct Choice, _asn_ctx),
 	offsetof(struct Choice, present),
 	sizeof(((struct Choice *)0)->present),
-	asn_MAP_Choice_1_tag2el,
+	asn_MAP_Choice_tag2el_1,
 	3,	/* Count of tags in the map */
-	0	/* Whether extensible */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_Choice = {
 	"Choice",
@@ -316,13 +340,15 @@
 	CHOICE_encode_der,
 	CHOICE_decode_xer,
 	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	CHOICE_outmost_tag,
 	0,	/* No effective tags (pointer) */
 	0,	/* No effective tags (count) */
 	0,	/* No tags (pointer) */
 	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
 	asn_MBR_Choice_1,
 	3,	/* Elements count */
-	&asn_SPC_Choice_1_specs	/* Additional specs */
+	&asn_SPC_Choice_specs_1	/* Additional specs */
 };
 
diff --git a/tests/94-set-optionals-OK.asn1.-P b/tests/94-set-optionals-OK.asn1.-P
index c1c4dd9..879cb06 100644
--- a/tests/94-set-optionals-OK.asn1.-P
+++ b/tests/94-set-optionals-OK.asn1.-P
@@ -61,6 +61,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m0"
 		},
 	{ ATF_POINTER, 1, offsetof(struct TestSet, m1),
@@ -68,6 +70,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m1"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct TestSet, m2),
@@ -75,6 +79,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m2"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct TestSet, m3),
@@ -82,6 +88,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m3"
 		},
 	{ ATF_POINTER, 1, offsetof(struct TestSet, m4),
@@ -89,6 +97,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m4"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct TestSet, m5),
@@ -96,6 +106,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m5"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct TestSet, m6),
@@ -103,6 +115,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m6"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct TestSet, m7),
@@ -110,6 +124,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m7"
 		},
 	{ ATF_POINTER, 1, offsetof(struct TestSet, m8),
@@ -117,6 +133,8 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m8"
 		},
 	{ ATF_NOFLAGS, 0, offsetof(struct TestSet, m9),
@@ -124,13 +142,15 @@
 		.tag_mode = -1,	/* IMPLICIT tag at current level */
 		.type = &asn_DEF_VisibleString,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
 		.name = "m9"
 		},
 };
-static ber_tlv_tag_t asn_DEF_TestSet_1_tags[] = {
+static ber_tlv_tag_t asn_DEF_TestSet_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_TestSet_1_tag2el[] = {
+static asn_TYPE_tag2member_t asn_MAP_TestSet_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* m0 at 15 */
     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* m1 at 16 */
     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* m2 at 17 */
@@ -142,20 +162,20 @@
     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* m8 at 23 */
     { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* m9 at 24 */
 };
-static uint8_t asn_MAP_TestSet_1_mmap[(10 + (8 * sizeof(unsigned int)) - 1) / 8] = {
+static uint8_t asn_MAP_TestSet_mmap_1[(10 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 	(1 << 7) | (0 << 6) | (1 << 5) | (1 << 4) | (0 << 3) | (1 << 2) | (1 << 1) | (1 << 0),
 	(0 << 7) | (1 << 6)
 };
-static asn_SET_specifics_t asn_SPC_TestSet_1_specs = {
+static asn_SET_specifics_t asn_SPC_TestSet_specs_1 = {
 	sizeof(struct TestSet),
 	offsetof(struct TestSet, _asn_ctx),
 	offsetof(struct TestSet, _presence_map),
-	asn_MAP_TestSet_1_tag2el,
+	asn_MAP_TestSet_tag2el_1,
 	10,	/* Count of tags in the map */
-	asn_MAP_TestSet_1_tag2el,	/* Same as above */
+	asn_MAP_TestSet_tag2el_1,	/* Same as above */
 	10,	/* Count of tags in the CXER map */
 	1,	/* Whether extensible */
-	(unsigned int *)asn_MAP_TestSet_1_mmap	/* Mandatory elements map */
+	(unsigned int *)asn_MAP_TestSet_mmap_1	/* Mandatory elements map */
 };
 asn_TYPE_descriptor_t asn_DEF_TestSet = {
 	"TestSet",
@@ -167,15 +187,17 @@
 	SET_encode_der,
 	SET_decode_xer,
 	SET_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_TestSet_1_tags,
-	sizeof(asn_DEF_TestSet_1_tags)
-		/sizeof(asn_DEF_TestSet_1_tags[0]), /* 1 */
-	asn_DEF_TestSet_1_tags,	/* Same as above */
-	sizeof(asn_DEF_TestSet_1_tags)
-		/sizeof(asn_DEF_TestSet_1_tags[0]), /* 1 */
+	asn_DEF_TestSet_tags_1,
+	sizeof(asn_DEF_TestSet_tags_1)
+		/sizeof(asn_DEF_TestSet_tags_1[0]), /* 1 */
+	asn_DEF_TestSet_tags_1,	/* Same as above */
+	sizeof(asn_DEF_TestSet_tags_1)
+		/sizeof(asn_DEF_TestSet_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
 	asn_MBR_TestSet_1,
 	10,	/* Elements count */
-	&asn_SPC_TestSet_1_specs	/* Additional specs */
+	&asn_SPC_TestSet_specs_1	/* Additional specs */
 };
 
diff --git a/tests/95-choice-per-order-OK.asn1 b/tests/95-choice-per-order-OK.asn1
new file mode 100644
index 0000000..2aeb4f7
--- /dev/null
+++ b/tests/95-choice-per-order-OK.asn1
@@ -0,0 +1,30 @@
+
+-- OK: Everything is fine
+
+-- iso.org.dod.internet.private.enterprise (1.3.6.1.4.1)
+-- .spelio.software.asn1c.test (9363.1.5.1)
+-- .95
+
+ModuleCHOICE-PER-Ordering
+	{ iso org(3) dod(6) internet (1) private(4) enterprise(1)
+		spelio(9363) software(1) asn1c(5) test(1) 95 }
+	DEFINITIONS ::=
+BEGIN
+
+	Choice ::= CHOICE {
+		roid	RELATIVE-OID,
+		bitstr	BIT STRING,
+		ch	CHOICE {
+				null	NULL,
+				int	INTEGER
+			},
+		...,
+		bool	BOOLEAN
+	}
+
+	Choice2 ::= CHOICE {
+		bitstr	[0] BIT STRING,
+		roid	[1] RELATIVE-OID
+	}
+
+END
diff --git a/tests/95-choice-per-order-OK.asn1.-P b/tests/95-choice-per-order-OK.asn1.-P
new file mode 100644
index 0000000..c1f726b
--- /dev/null
+++ b/tests/95-choice-per-order-OK.asn1.-P
@@ -0,0 +1,284 @@
+
+/*** <<< INCLUDES [Choice] >>> ***/
+
+#include <RELATIVE-OID.h>
+#include <BIT_STRING.h>
+#include <BOOLEAN.h>
+#include <NULL.h>
+#include <INTEGER.h>
+#include <constr_CHOICE.h>
+
+/*** <<< DEPS [Choice] >>> ***/
+
+typedef enum Choice_PR {
+	Choice_PR_NOTHING,	/* No components present */
+	Choice_PR_roid,
+	Choice_PR_bitstr,
+	Choice_PR_ch,
+	/* Extensions may appear below */
+	Choice_PR_bool,
+} Choice_PR;
+typedef enum ch_PR {
+	ch_PR_NOTHING,	/* No components present */
+	ch_PR_null,
+	ch_PR_int,
+} ch_PR;
+
+/*** <<< TYPE-DECLS [Choice] >>> ***/
+
+typedef struct Choice {
+	Choice_PR present;
+	union Choice_u {
+		RELATIVE_OID_t	 roid;
+		BIT_STRING_t	 bitstr;
+		struct ch {
+			ch_PR present;
+			union Choice__ch_u {
+				NULL_t	 null;
+				INTEGER_t	 Int;
+			} choice;
+			
+			/* Context for parsing across buffer boundaries */
+			asn_struct_ctx_t _asn_ctx;
+		} ch;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+		BOOLEAN_t	 bool;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Choice_t;
+
+/*** <<< FUNC-DECLS [Choice] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Choice;
+
+/*** <<< STAT-DEFS [Choice] >>> ***/
+
+static asn_TYPE_member_t asn_MBR_ch_4[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ch, choice.null),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_NULL,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "null"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ch, choice.Int),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_INTEGER,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "int"
+		},
+};
+static asn_TYPE_tag2member_t asn_MAP_ch_tag2el_4[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* int at 20 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 0, 0, 0 } /* null at 18 */
+};
+static asn_CHOICE_specifics_t asn_SPC_ch_specs_4 = {
+	sizeof(struct ch),
+	offsetof(struct ch, _asn_ctx),
+	offsetof(struct ch, present),
+	sizeof(((struct ch *)0)->present),
+	asn_MAP_ch_tag2el_4,
+	2,	/* Count of tags in the map */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ch_4 = {
+	"ch",
+	"ch",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_ch_4,
+	2,	/* Elements count */
+	&asn_SPC_ch_specs_4	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_Choice_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.roid),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (13 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_RELATIVE_OID,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "roid"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.bitstr),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_BIT_STRING,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "bitstr"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.ch),
+		.tag = -1 /* Ambiguous tag (CHOICE?) */,
+		.tag_mode = 0,
+		.type = &asn_DEF_ch_4,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "ch"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.bool),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_BOOLEAN,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "bool"
+		},
+};
+static asn_TYPE_tag2member_t asn_MAP_Choice_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 3, 0, 0 }, /* bool at 22 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, 0, 0 }, /* int at 20 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 1, 0, 0 }, /* bitstr at 16 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 2, 0, 0 }, /* null at 18 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (13 << 2)), 0, 0, 0 } /* roid at 15 */
+};
+static asn_CHOICE_specifics_t asn_SPC_Choice_specs_1 = {
+	sizeof(struct Choice),
+	offsetof(struct Choice, _asn_ctx),
+	offsetof(struct Choice, present),
+	sizeof(((struct Choice *)0)->present),
+	asn_MAP_Choice_tag2el_1,
+	5,	/* Count of tags in the map */
+	.canonical_order = 0,
+	.ext_start = 3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_Choice = {
+	"Choice",
+	"Choice",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_Choice_1,
+	4,	/* Elements count */
+	&asn_SPC_Choice_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Choice2] >>> ***/
+
+#include <BIT_STRING.h>
+#include <RELATIVE-OID.h>
+#include <constr_CHOICE.h>
+
+/*** <<< DEPS [Choice2] >>> ***/
+
+typedef enum Choice2_PR {
+	Choice2_PR_NOTHING,	/* No components present */
+	Choice2_PR_bitstr,
+	Choice2_PR_roid,
+} Choice2_PR;
+
+/*** <<< TYPE-DECLS [Choice2] >>> ***/
+
+typedef struct Choice2 {
+	Choice2_PR present;
+	union Choice2_u {
+		BIT_STRING_t	 bitstr;
+		RELATIVE_OID_t	 roid;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Choice2_t;
+
+/*** <<< FUNC-DECLS [Choice2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Choice2;
+
+/*** <<< STAT-DEFS [Choice2] >>> ***/
+
+static asn_TYPE_member_t asn_MBR_Choice2_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice2, choice.bitstr),
+		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		.tag_mode = +1,	/* EXPLICIT tag at current level */
+		.type = &asn_DEF_BIT_STRING,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "bitstr"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice2, choice.roid),
+		.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		.tag_mode = +1,	/* EXPLICIT tag at current level */
+		.type = &asn_DEF_RELATIVE_OID,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "roid"
+		},
+};
+static asn_TYPE_tag2member_t asn_MAP_Choice2_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* bitstr at 26 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* roid at 27 */
+};
+static asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
+	sizeof(struct Choice2),
+	offsetof(struct Choice2, _asn_ctx),
+	offsetof(struct Choice2, present),
+	sizeof(((struct Choice2 *)0)->present),
+	asn_MAP_Choice2_tag2el_1,
+	2,	/* Count of tags in the map */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_Choice2 = {
+	"Choice2",
+	"Choice2",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0,	/* No PER decoder, -gen-PER to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_Choice2_1,
+	2,	/* Elements count */
+	&asn_SPC_Choice2_specs_1	/* Additional specs */
+};
+
diff --git a/tests/95-choice-per-order-OK.asn1.-Pgen-PER b/tests/95-choice-per-order-OK.asn1.-Pgen-PER
new file mode 100644
index 0000000..68e9ad9
--- /dev/null
+++ b/tests/95-choice-per-order-OK.asn1.-Pgen-PER
@@ -0,0 +1,302 @@
+
+/*** <<< INCLUDES [Choice] >>> ***/
+
+#include <RELATIVE-OID.h>
+#include <BIT_STRING.h>
+#include <BOOLEAN.h>
+#include <NULL.h>
+#include <INTEGER.h>
+#include <constr_CHOICE.h>
+
+/*** <<< DEPS [Choice] >>> ***/
+
+typedef enum Choice_PR {
+	Choice_PR_NOTHING,	/* No components present */
+	Choice_PR_roid,
+	Choice_PR_bitstr,
+	Choice_PR_ch,
+	/* Extensions may appear below */
+	Choice_PR_bool,
+} Choice_PR;
+typedef enum ch_PR {
+	ch_PR_NOTHING,	/* No components present */
+	ch_PR_null,
+	ch_PR_int,
+} ch_PR;
+
+/*** <<< TYPE-DECLS [Choice] >>> ***/
+
+typedef struct Choice {
+	Choice_PR present;
+	union Choice_u {
+		RELATIVE_OID_t	 roid;
+		BIT_STRING_t	 bitstr;
+		struct ch {
+			ch_PR present;
+			union Choice__ch_u {
+				NULL_t	 null;
+				INTEGER_t	 Int;
+			} choice;
+			
+			/* Context for parsing across buffer boundaries */
+			asn_struct_ctx_t _asn_ctx;
+		} ch;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+		BOOLEAN_t	 bool;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Choice_t;
+
+/*** <<< FUNC-DECLS [Choice] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Choice;
+
+/*** <<< STAT-DEFS [Choice] >>> ***/
+
+static asn_TYPE_member_t asn_MBR_ch_4[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ch, choice.null),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_NULL,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "null"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct ch, choice.Int),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_INTEGER,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "int"
+		},
+};
+static int asn_MAP_ch_cmap_4[] = { 1, 0 };
+static asn_TYPE_tag2member_t asn_MAP_ch_tag2el_4[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* int at 20 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 0, 0, 0 } /* null at 18 */
+};
+static asn_CHOICE_specifics_t asn_SPC_ch_specs_4 = {
+	sizeof(struct ch),
+	offsetof(struct ch, _asn_ctx),
+	offsetof(struct ch, present),
+	sizeof(((struct ch *)0)->present),
+	asn_MAP_ch_tag2el_4,
+	2,	/* Count of tags in the map */
+	.canonical_order = asn_MAP_ch_cmap_4,	/* Canonically sorted */
+	.ext_start = -1	/* Extensions start */
+};
+static asn_per_constraints_t asn_PER_ch_constr_4 = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_ch_4 = {
+	"ch",
+	"ch",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_ch_constr_4,
+	asn_MBR_ch_4,
+	2,	/* Elements count */
+	&asn_SPC_ch_specs_4	/* Additional specs */
+};
+
+static asn_per_constraints_t asn_PER_memb_ch_constr_4 = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+static asn_TYPE_member_t asn_MBR_Choice_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.roid),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (13 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_RELATIVE_OID,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "roid"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.bitstr),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_BIT_STRING,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "bitstr"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.ch),
+		.tag = -1 /* Ambiguous tag (CHOICE?) */,
+		.tag_mode = 0,
+		.type = &asn_DEF_ch_4,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = &asn_PER_memb_ch_constr_4,
+		.default_value = 0,
+		.name = "ch"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.bool),
+		.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
+		.tag_mode = 0,
+		.type = &asn_DEF_BOOLEAN,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "bool"
+		},
+};
+static int asn_MAP_Choice_cmap_1[] = { 2, 1, 0, 3 };
+static asn_TYPE_tag2member_t asn_MAP_Choice_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 3, 0, 0 }, /* bool at 22 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, 0, 0 }, /* int at 20 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (3 << 2)), 1, 0, 0 }, /* bitstr at 16 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 2, 0, 0 }, /* null at 18 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (13 << 2)), 0, 0, 0 } /* roid at 15 */
+};
+static asn_CHOICE_specifics_t asn_SPC_Choice_specs_1 = {
+	sizeof(struct Choice),
+	offsetof(struct Choice, _asn_ctx),
+	offsetof(struct Choice, present),
+	sizeof(((struct Choice *)0)->present),
+	asn_MAP_Choice_tag2el_1,
+	5,	/* Count of tags in the map */
+	.canonical_order = asn_MAP_Choice_cmap_1,	/* Canonically sorted */
+	.ext_start = 3	/* Extensions start */
+};
+static asn_per_constraints_t asn_PER_Choice_constr_1 = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  2 }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Choice = {
+	"Choice",
+	"Choice",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_Choice_constr_1,
+	asn_MBR_Choice_1,
+	4,	/* Elements count */
+	&asn_SPC_Choice_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Choice2] >>> ***/
+
+#include <BIT_STRING.h>
+#include <RELATIVE-OID.h>
+#include <constr_CHOICE.h>
+
+/*** <<< DEPS [Choice2] >>> ***/
+
+typedef enum Choice2_PR {
+	Choice2_PR_NOTHING,	/* No components present */
+	Choice2_PR_bitstr,
+	Choice2_PR_roid,
+} Choice2_PR;
+
+/*** <<< TYPE-DECLS [Choice2] >>> ***/
+
+typedef struct Choice2 {
+	Choice2_PR present;
+	union Choice2_u {
+		BIT_STRING_t	 bitstr;
+		RELATIVE_OID_t	 roid;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Choice2_t;
+
+/*** <<< FUNC-DECLS [Choice2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Choice2;
+
+/*** <<< STAT-DEFS [Choice2] >>> ***/
+
+static asn_TYPE_member_t asn_MBR_Choice2_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice2, choice.bitstr),
+		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		.tag_mode = +1,	/* EXPLICIT tag at current level */
+		.type = &asn_DEF_BIT_STRING,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "bitstr"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Choice2, choice.roid),
+		.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		.tag_mode = +1,	/* EXPLICIT tag at current level */
+		.type = &asn_DEF_RELATIVE_OID,
+		.memb_constraints = 0,	/* Defer constraints checking to the member type */
+		.per_constraints = 0,	/* No PER visible constraints */
+		.default_value = 0,
+		.name = "roid"
+		},
+};
+static asn_TYPE_tag2member_t asn_MAP_Choice2_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* bitstr at 26 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* roid at 27 */
+};
+static asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
+	sizeof(struct Choice2),
+	offsetof(struct Choice2, _asn_ctx),
+	offsetof(struct Choice2, present),
+	sizeof(((struct Choice2 *)0)->present),
+	asn_MAP_Choice2_tag2el_1,
+	2,	/* Count of tags in the map */
+	.canonical_order = 0,
+	.ext_start = -1	/* Extensions start */
+};
+static asn_per_constraints_t asn_PER_Choice2_constr_1 = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 }
+};
+asn_TYPE_descriptor_t asn_DEF_Choice2 = {
+	"Choice2",
+	"Choice2",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_Choice2_constr_1,
+	asn_MBR_Choice2_1,
+	2,	/* Elements count */
+	&asn_SPC_Choice2_specs_1	/* Additional specs */
+};
+