per support

1 files changed, 320 insertions, 7 deletions

diff --git a/tests/50-constraint-OK.asn1.-Pgen-PER b/tests/50-constraint-OK.asn1.-Pgen-PER
index 8736e4cb..53adbebe 100644
--- a/tests/50-constraint-OK.asn1.-Pgen-PER
+++ b/tests/50-constraint-OK.asn1.-Pgen-PER
@@ -18,6 +18,7 @@ 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;
+per_type_encoder_f Int1_encode_uper;
 
 /*** <<< CODE [Int1] >>> ***/
 
@@ -42,6 +43,7 @@ Int1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
 	td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
 	td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
@@ -100,6 +102,14 @@ Int1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Int1_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Int1_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Int1] >>> ***/
 
@@ -117,6 +127,7 @@ asn_TYPE_descriptor_t asn_DEF_Int1 = {
 	Int1_decode_xer,
 	Int1_encode_xer,
 	Int1_decode_uper,
+	Int1_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Int1_tags_1,
 	sizeof(asn_DEF_Int1_tags_1)
@@ -149,6 +160,7 @@ 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;
+per_type_encoder_f Int2_encode_uper;
 
 /*** <<< CODE [Int2] >>> ***/
 
@@ -192,6 +204,7 @@ Int2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_Int1.xer_decoder;
 	td->xer_encoder    = asn_DEF_Int1.xer_encoder;
 	td->uper_decoder   = asn_DEF_Int1.uper_decoder;
+	td->uper_encoder   = asn_DEF_Int1.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Int1.per_constraints;
 	td->elements       = asn_DEF_Int1.elements;
@@ -250,6 +263,14 @@ Int2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Int2_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Int2_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Int2] >>> ***/
 
@@ -271,6 +292,7 @@ asn_TYPE_descriptor_t asn_DEF_Int2 = {
 	Int2_decode_xer,
 	Int2_encode_xer,
 	Int2_decode_uper,
+	Int2_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Int2_tags_1,
 	sizeof(asn_DEF_Int2_tags_1)
@@ -303,6 +325,7 @@ 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;
+per_type_encoder_f Int3_encode_uper;
 
 /*** <<< CODE [Int3] >>> ***/
 
@@ -350,6 +373,7 @@ Int3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_Int2.xer_decoder;
 	td->xer_encoder    = asn_DEF_Int2.xer_encoder;
 	td->uper_decoder   = asn_DEF_Int2.uper_decoder;
+	td->uper_encoder   = asn_DEF_Int2.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Int2.per_constraints;
 	td->elements       = asn_DEF_Int2.elements;
@@ -408,6 +432,14 @@ Int3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Int3_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Int3_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Int3] >>> ***/
 
@@ -429,6 +461,7 @@ asn_TYPE_descriptor_t asn_DEF_Int3 = {
 	Int3_decode_xer,
 	Int3_encode_xer,
 	Int3_decode_uper,
+	Int3_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Int3_tags_1,
 	sizeof(asn_DEF_Int3_tags_1)
@@ -461,6 +494,7 @@ 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;
+per_type_encoder_f Int4_encode_uper;
 
 /*** <<< CODE [Int4] >>> ***/
 
@@ -508,6 +542,7 @@ Int4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_Int3.xer_decoder;
 	td->xer_encoder    = asn_DEF_Int3.xer_encoder;
 	td->uper_decoder   = asn_DEF_Int3.uper_decoder;
+	td->uper_encoder   = asn_DEF_Int3.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Int3.per_constraints;
 	td->elements       = asn_DEF_Int3.elements;
@@ -566,6 +601,14 @@ Int4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Int4_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Int4_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Int4] >>> ***/
 
@@ -587,6 +630,7 @@ asn_TYPE_descriptor_t asn_DEF_Int4 = {
 	Int4_decode_xer,
 	Int4_encode_xer,
 	Int4_decode_uper,
+	Int4_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Int4_tags_1,
 	sizeof(asn_DEF_Int4_tags_1)
@@ -619,6 +663,7 @@ 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;
+per_type_encoder_f Int5_encode_uper;
 
 /*** <<< CODE [Int5] >>> ***/
 
@@ -666,6 +711,7 @@ Int5_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_Int4.xer_decoder;
 	td->xer_encoder    = asn_DEF_Int4.xer_encoder;
 	td->uper_decoder   = asn_DEF_Int4.uper_decoder;
+	td->uper_encoder   = asn_DEF_Int4.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Int4.per_constraints;
 	td->elements       = asn_DEF_Int4.elements;
@@ -724,6 +770,14 @@ Int5_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Int5_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Int5_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Int5] >>> ***/
 
@@ -745,6 +799,7 @@ asn_TYPE_descriptor_t asn_DEF_Int5 = {
 	Int5_decode_xer,
 	Int5_encode_xer,
 	Int5_decode_uper,
+	Int5_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Int5_tags_1,
 	sizeof(asn_DEF_Int5_tags_1)
@@ -777,6 +832,7 @@ 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;
+per_type_encoder_f ExtensibleExtensions_encode_uper;
 
 /*** <<< CODE [ExtensibleExtensions] >>> ***/
 
@@ -824,6 +880,7 @@ ExtensibleExtensions_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
 	td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
 	td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_INTEGER.per_constraints;
 	td->elements       = asn_DEF_INTEGER.elements;
@@ -882,6 +939,14 @@ ExtensibleExtensions_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descri
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+ExtensibleExtensions_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	ExtensibleExtensions_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [ExtensibleExtensions] >>> ***/
 
@@ -903,6 +968,7 @@ asn_TYPE_descriptor_t asn_DEF_ExtensibleExtensions = {
 	ExtensibleExtensions_decode_xer,
 	ExtensibleExtensions_encode_xer,
 	ExtensibleExtensions_decode_uper,
+	ExtensibleExtensions_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_ExtensibleExtensions_tags_1,
 	sizeof(asn_DEF_ExtensibleExtensions_tags_1)
@@ -935,6 +1001,7 @@ 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;
+per_type_encoder_f Str1_encode_uper;
 
 /*** <<< CODE [Str1] >>> ***/
 
@@ -959,6 +1026,7 @@ Str1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
 	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
 	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	td->uper_encoder   = asn_DEF_IA5String.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_IA5String.per_constraints;
 	td->elements       = asn_DEF_IA5String.elements;
@@ -1017,6 +1085,14 @@ Str1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Str1_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Str1_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Str1] >>> ***/
 
@@ -1034,6 +1110,7 @@ asn_TYPE_descriptor_t asn_DEF_Str1 = {
 	Str1_decode_xer,
 	Str1_encode_xer,
 	Str1_decode_uper,
+	Str1_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Str1_tags_1,
 	sizeof(asn_DEF_Str1_tags_1)
@@ -1066,6 +1143,7 @@ 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;
+per_type_encoder_f Str2_encode_uper;
 
 /*** <<< CTABLES [Str2] >>> ***/
 
@@ -1125,6 +1203,7 @@ Str2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_Str1.xer_decoder;
 	td->xer_encoder    = asn_DEF_Str1.xer_encoder;
 	td->uper_decoder   = asn_DEF_Str1.uper_decoder;
+	td->uper_encoder   = asn_DEF_Str1.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Str1.per_constraints;
 	td->elements       = asn_DEF_Str1.elements;
@@ -1183,6 +1262,14 @@ Str2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Str2_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Str2_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Str2] >>> ***/
 
@@ -1204,6 +1291,7 @@ asn_TYPE_descriptor_t asn_DEF_Str2 = {
 	Str2_decode_xer,
 	Str2_encode_xer,
 	Str2_decode_uper,
+	Str2_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Str2_tags_1,
 	sizeof(asn_DEF_Str2_tags_1)
@@ -1236,6 +1324,7 @@ 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;
+per_type_encoder_f Str3_encode_uper;
 
 /*** <<< CTABLES [Str3] >>> ***/
 
@@ -1306,6 +1395,7 @@ Str3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_Str2.xer_decoder;
 	td->xer_encoder    = asn_DEF_Str2.xer_encoder;
 	td->uper_decoder   = asn_DEF_Str2.uper_decoder;
+	td->uper_encoder   = asn_DEF_Str2.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Str2.per_constraints;
 	td->elements       = asn_DEF_Str2.elements;
@@ -1364,6 +1454,14 @@ Str3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Str3_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Str3_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Str3] >>> ***/
 
@@ -1385,6 +1483,7 @@ asn_TYPE_descriptor_t asn_DEF_Str3 = {
 	Str3_decode_xer,
 	Str3_encode_xer,
 	Str3_decode_uper,
+	Str3_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Str3_tags_1,
 	sizeof(asn_DEF_Str3_tags_1)
@@ -1417,6 +1516,7 @@ 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;
+per_type_encoder_f Str4_encode_uper;
 
 /*** <<< CTABLES [Str4] >>> ***/
 
@@ -1473,6 +1573,7 @@ Str4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
 	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
 	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	td->uper_encoder   = asn_DEF_IA5String.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_IA5String.per_constraints;
 	td->elements       = asn_DEF_IA5String.elements;
@@ -1531,6 +1632,14 @@ Str4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Str4_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Str4_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Str4] >>> ***/
 
@@ -1552,6 +1661,7 @@ asn_TYPE_descriptor_t asn_DEF_Str4 = {
 	Str4_decode_xer,
 	Str4_encode_xer,
 	Str4_decode_uper,
+	Str4_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Str4_tags_1,
 	sizeof(asn_DEF_Str4_tags_1)
@@ -1584,6 +1694,7 @@ 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;
+per_type_encoder_f PER_Visible_encode_uper;
 
 /*** <<< CTABLES [PER-Visible] >>> ***/
 
@@ -1640,6 +1751,7 @@ PER_Visible_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
 	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
 	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	td->uper_encoder   = asn_DEF_IA5String.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_IA5String.per_constraints;
 	td->elements       = asn_DEF_IA5String.elements;
@@ -1698,6 +1810,14 @@ PER_Visible_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *t
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+PER_Visible_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	PER_Visible_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [PER-Visible] >>> ***/
 
@@ -1719,6 +1839,7 @@ asn_TYPE_descriptor_t asn_DEF_PER_Visible = {
 	PER_Visible_decode_xer,
 	PER_Visible_encode_xer,
 	PER_Visible_decode_uper,
+	PER_Visible_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_PER_Visible_tags_1,
 	sizeof(asn_DEF_PER_Visible_tags_1)
@@ -1751,6 +1872,7 @@ 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;
+per_type_encoder_f PER_Visible_2_encode_uper;
 
 /*** <<< CTABLES [PER-Visible-2] >>> ***/
 
@@ -1807,6 +1929,7 @@ PER_Visible_2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_PER_Visible.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
@@ -1865,6 +1988,14 @@ PER_Visible_2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+PER_Visible_2_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	PER_Visible_2_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [PER-Visible-2] >>> ***/
 
@@ -1886,6 +2017,7 @@ asn_TYPE_descriptor_t asn_DEF_PER_Visible_2 = {
 	PER_Visible_2_decode_xer,
 	PER_Visible_2_encode_xer,
 	PER_Visible_2_decode_uper,
+	PER_Visible_2_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_PER_Visible_2_tags_1,
 	sizeof(asn_DEF_PER_Visible_2_tags_1)
@@ -1918,6 +2050,7 @@ 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;
+per_type_encoder_f Not_PER_Visible_1_encode_uper;
 
 /*** <<< CTABLES [Not-PER-Visible-1] >>> ***/
 
@@ -1974,6 +2107,7 @@ Not_PER_Visible_1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_PER_Visible.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
@@ -2032,6 +2166,14 @@ Not_PER_Visible_1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descripto
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Not_PER_Visible_1_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Not_PER_Visible_1_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Not-PER-Visible-1] >>> ***/
 
@@ -2053,6 +2195,7 @@ asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_1 = {
 	Not_PER_Visible_1_decode_xer,
 	Not_PER_Visible_1_encode_xer,
 	Not_PER_Visible_1_decode_uper,
+	Not_PER_Visible_1_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Not_PER_Visible_1_tags_1,
 	sizeof(asn_DEF_Not_PER_Visible_1_tags_1)
@@ -2085,6 +2228,7 @@ 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;
+per_type_encoder_f Not_PER_Visible_2_encode_uper;
 
 /*** <<< CTABLES [Not-PER-Visible-2] >>> ***/
 
@@ -2141,6 +2285,7 @@ Not_PER_Visible_2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_PER_Visible.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
@@ -2199,6 +2344,14 @@ Not_PER_Visible_2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descripto
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Not_PER_Visible_2_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Not_PER_Visible_2_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Not-PER-Visible-2] >>> ***/
 
@@ -2220,6 +2373,7 @@ asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_2 = {
 	Not_PER_Visible_2_decode_xer,
 	Not_PER_Visible_2_encode_xer,
 	Not_PER_Visible_2_decode_uper,
+	Not_PER_Visible_2_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Not_PER_Visible_2_tags_1,
 	sizeof(asn_DEF_Not_PER_Visible_2_tags_1)
@@ -2252,6 +2406,7 @@ 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;
+per_type_encoder_f Not_PER_Visible_3_encode_uper;
 
 /*** <<< CTABLES [Not-PER-Visible-3] >>> ***/
 
@@ -2308,6 +2463,7 @@ Not_PER_Visible_3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_PER_Visible.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
@@ -2366,6 +2522,14 @@ Not_PER_Visible_3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descripto
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Not_PER_Visible_3_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Not_PER_Visible_3_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Not-PER-Visible-3] >>> ***/
 
@@ -2387,6 +2551,7 @@ asn_TYPE_descriptor_t asn_DEF_Not_PER_Visible_3 = {
 	Not_PER_Visible_3_decode_xer,
 	Not_PER_Visible_3_encode_xer,
 	Not_PER_Visible_3_decode_uper,
+	Not_PER_Visible_3_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Not_PER_Visible_3_tags_1,
 	sizeof(asn_DEF_Not_PER_Visible_3_tags_1)
@@ -2419,6 +2584,7 @@ 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;
+per_type_encoder_f SIZE_but_not_FROM_encode_uper;
 
 /*** <<< CTABLES [SIZE-but-not-FROM] >>> ***/
 
@@ -2478,6 +2644,7 @@ SIZE_but_not_FROM_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_PER_Visible.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
@@ -2536,6 +2703,14 @@ SIZE_but_not_FROM_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descripto
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+SIZE_but_not_FROM_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SIZE_but_not_FROM_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [SIZE-but-not-FROM] >>> ***/
 
@@ -2557,6 +2732,7 @@ asn_TYPE_descriptor_t asn_DEF_SIZE_but_not_FROM = {
 	SIZE_but_not_FROM_decode_xer,
 	SIZE_but_not_FROM_encode_xer,
 	SIZE_but_not_FROM_decode_uper,
+	SIZE_but_not_FROM_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_SIZE_but_not_FROM_tags_1,
 	sizeof(asn_DEF_SIZE_but_not_FROM_tags_1)
@@ -2589,6 +2765,7 @@ 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;
+per_type_encoder_f SIZE_and_FROM_encode_uper;
 
 /*** <<< CTABLES [SIZE-and-FROM] >>> ***/
 
@@ -2648,6 +2825,7 @@ SIZE_and_FROM_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_PER_Visible.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
@@ -2706,6 +2884,14 @@ SIZE_and_FROM_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+SIZE_and_FROM_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SIZE_and_FROM_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [SIZE-and-FROM] >>> ***/
 
@@ -2727,6 +2913,7 @@ asn_TYPE_descriptor_t asn_DEF_SIZE_and_FROM = {
 	SIZE_and_FROM_decode_xer,
 	SIZE_and_FROM_encode_xer,
 	SIZE_and_FROM_decode_uper,
+	SIZE_and_FROM_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_SIZE_and_FROM_tags_1,
 	sizeof(asn_DEF_SIZE_and_FROM_tags_1)
@@ -2759,6 +2946,7 @@ 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;
+per_type_encoder_f Neither_SIZE_nor_FROM_encode_uper;
 
 /*** <<< CTABLES [Neither-SIZE-nor-FROM] >>> ***/
 
@@ -2815,6 +3003,7 @@ Neither_SIZE_nor_FROM_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_PER_Visible.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_PER_Visible.per_constraints;
 	td->elements       = asn_DEF_PER_Visible.elements;
@@ -2873,6 +3062,14 @@ Neither_SIZE_nor_FROM_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descr
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Neither_SIZE_nor_FROM_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Neither_SIZE_nor_FROM_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Neither-SIZE-nor-FROM] >>> ***/
 
@@ -2894,6 +3091,7 @@ asn_TYPE_descriptor_t asn_DEF_Neither_SIZE_nor_FROM = {
 	Neither_SIZE_nor_FROM_decode_xer,
 	Neither_SIZE_nor_FROM_encode_xer,
 	Neither_SIZE_nor_FROM_decode_uper,
+	Neither_SIZE_nor_FROM_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Neither_SIZE_nor_FROM_tags_1,
 	sizeof(asn_DEF_Neither_SIZE_nor_FROM_tags_1)
@@ -2926,6 +3124,7 @@ 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;
+per_type_encoder_f Utf8_4_encode_uper;
 
 /*** <<< CTABLES [Utf8-4] >>> ***/
 
@@ -2976,6 +3175,7 @@ Utf8_4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_UTF8String.xer_decoder;
 	td->xer_encoder    = asn_DEF_UTF8String.xer_encoder;
 	td->uper_decoder   = asn_DEF_UTF8String.uper_decoder;
+	td->uper_encoder   = asn_DEF_UTF8String.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_UTF8String.per_constraints;
 	td->elements       = asn_DEF_UTF8String.elements;
@@ -3034,6 +3234,14 @@ Utf8_4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Utf8_4_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Utf8_4_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Utf8-4] >>> ***/
 
@@ -3055,6 +3263,7 @@ asn_TYPE_descriptor_t asn_DEF_Utf8_4 = {
 	Utf8_4_decode_xer,
 	Utf8_4_encode_xer,
 	Utf8_4_decode_uper,
+	Utf8_4_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Utf8_4_tags_1,
 	sizeof(asn_DEF_Utf8_4_tags_1)
@@ -3087,6 +3296,7 @@ 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;
+per_type_encoder_f Utf8_3_encode_uper;
 
 /*** <<< CTABLES [Utf8-3] >>> ***/
 
@@ -3165,6 +3375,7 @@ Utf8_3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_Utf8_2.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Utf8_2.per_constraints;
 	td->elements       = asn_DEF_Utf8_2.elements;
@@ -3223,6 +3434,14 @@ Utf8_3_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Utf8_3_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Utf8_3_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Utf8-3] >>> ***/
 
@@ -3244,6 +3463,7 @@ asn_TYPE_descriptor_t asn_DEF_Utf8_3 = {
 	Utf8_3_decode_xer,
 	Utf8_3_encode_xer,
 	Utf8_3_decode_uper,
+	Utf8_3_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Utf8_3_tags_1,
 	sizeof(asn_DEF_Utf8_3_tags_1)
@@ -3276,6 +3496,7 @@ 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;
+per_type_encoder_f Utf8_2_encode_uper;
 
 /*** <<< CODE [Utf8-2] >>> ***/
 
@@ -3324,6 +3545,7 @@ Utf8_2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	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;
+	td->uper_encoder   = asn_DEF_Utf8_1.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Utf8_1.per_constraints;
 	td->elements       = asn_DEF_Utf8_1.elements;
@@ -3382,6 +3604,14 @@ Utf8_2_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Utf8_2_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Utf8_2_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Utf8-2] >>> ***/
 
@@ -3403,6 +3633,7 @@ asn_TYPE_descriptor_t asn_DEF_Utf8_2 = {
 	Utf8_2_decode_xer,
 	Utf8_2_encode_xer,
 	Utf8_2_decode_uper,
+	Utf8_2_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Utf8_2_tags_1,
 	sizeof(asn_DEF_Utf8_2_tags_1)
@@ -3435,6 +3666,7 @@ 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;
+per_type_encoder_f Utf8_1_encode_uper;
 
 /*** <<< CODE [Utf8-1] >>> ***/
 
@@ -3459,6 +3691,7 @@ Utf8_1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_UTF8String.xer_decoder;
 	td->xer_encoder    = asn_DEF_UTF8String.xer_encoder;
 	td->uper_decoder   = asn_DEF_UTF8String.uper_decoder;
+	td->uper_encoder   = asn_DEF_UTF8String.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_UTF8String.per_constraints;
 	td->elements       = asn_DEF_UTF8String.elements;
@@ -3517,6 +3750,14 @@ Utf8_1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Utf8_1_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Utf8_1_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Utf8-1] >>> ***/
 
@@ -3534,6 +3775,7 @@ asn_TYPE_descriptor_t asn_DEF_Utf8_1 = {
 	Utf8_1_decode_xer,
 	Utf8_1_encode_xer,
 	Utf8_1_decode_uper,
+	Utf8_1_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Utf8_1_tags_1,
 	sizeof(asn_DEF_Utf8_1_tags_1)
@@ -3566,6 +3808,7 @@ 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;
+per_type_encoder_f VisibleIdentifier_encode_uper;
 
 /*** <<< CTABLES [VisibleIdentifier] >>> ***/
 
@@ -3637,6 +3880,7 @@ VisibleIdentifier_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_Identifier.xer_decoder;
 	td->xer_encoder    = asn_DEF_Identifier.xer_encoder;
 	td->uper_decoder   = asn_DEF_Identifier.uper_decoder;
+	td->uper_encoder   = asn_DEF_Identifier.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_Identifier.per_constraints;
 	td->elements       = asn_DEF_Identifier.elements;
@@ -3695,6 +3939,14 @@ VisibleIdentifier_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descripto
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+VisibleIdentifier_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	VisibleIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [VisibleIdentifier] >>> ***/
 
@@ -3712,6 +3964,7 @@ asn_TYPE_descriptor_t asn_DEF_VisibleIdentifier = {
 	VisibleIdentifier_decode_xer,
 	VisibleIdentifier_encode_xer,
 	VisibleIdentifier_decode_uper,
+	VisibleIdentifier_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_VisibleIdentifier_tags_1,
 	sizeof(asn_DEF_VisibleIdentifier_tags_1)
@@ -3793,6 +4046,7 @@ enum_c_6_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
 	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
 	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
 	td->elements       = asn_DEF_ENUMERATED.elements;
@@ -3851,6 +4105,14 @@ enum_c_6_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+static asn_enc_rval_t
+enum_c_6_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	enum_c_6_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 static int
 memb_int1_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
@@ -3947,28 +4209,43 @@ memb_int5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 
 /*** <<< STAT-DEFS [Sequence] >>> ***/
 
-static int asn_DFL_2_set_3(void **sptr) {
+static int asn_DFL_2_set_3(int set_value, void **sptr) {
 	Int1_t *st = *sptr;
 	
 	if(!st) {
+		if(!set_value) return -1;	/* Not a default value */
 		st = (*sptr = CALLOC(1, sizeof(*st)));
 		if(!st) return -1;
 	}
 	
-	/* Install default value 3 */
-	return asn_long2INTEGER(st, 3);
+	if(set_value) {
+		/* Install default value 3 */
+		return asn_long2INTEGER(st, 3);
+	} else {
+		/* Test default value 3 */
+		long value;
+		if(asn_INTEGER2long(st, &value))
+			return -1;
+		return (value == 3);
+	}
 }
-static int asn_DFL_5_set_1(void **sptr) {
+static int asn_DFL_5_set_1(int set_value, void **sptr) {
 	BOOLEAN_t *st = *sptr;
 	
 	if(!st) {
+		if(!set_value) return -1;	/* Not a default value */
 		st = (*sptr = CALLOC(1, sizeof(*st)));
 		if(!st) return -1;
 	}
 	
-	/* Install default value 1 */
-	*st = 1;
-	return 0;
+	if(set_value) {
+		/* Install default value 1 */
+		*st = 1;
+		return 0;
+	} else {
+		/* Test default value 1 */
+		return (*st == 1);
+	}
 }
 static asn_INTEGER_enum_map_t asn_MAP_enum_c_value2enum_6[] = {
 	{ 1,	3,	"one" },
@@ -4008,6 +4285,7 @@ asn_TYPE_descriptor_t asn_DEF_enum_c_6 = {
 	enum_c_6_decode_xer,
 	enum_c_6_encode_xer,
 	enum_c_6_decode_uper,
+	enum_c_6_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_enum_c_tags_6,
 	sizeof(asn_DEF_enum_c_tags_6)
@@ -4135,6 +4413,7 @@ asn_TYPE_descriptor_t asn_DEF_Sequence = {
 	SEQUENCE_decode_xer,
 	SEQUENCE_encode_xer,
 	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Sequence_tags_1,
 	sizeof(asn_DEF_Sequence_tags_1)
@@ -4211,6 +4490,7 @@ asn_TYPE_descriptor_t asn_DEF_SequenceOf = {
 	SEQUENCE_OF_decode_xer,
 	SEQUENCE_OF_encode_xer,
 	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_SequenceOf_tags_1,
 	sizeof(asn_DEF_SequenceOf_tags_1)
@@ -4251,6 +4531,7 @@ 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;
+per_type_encoder_f Enum0_encode_uper;
 
 /*** <<< CODE [Enum0] >>> ***/
 
@@ -4275,6 +4556,7 @@ Enum0_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
 	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
 	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
 	td->elements       = asn_DEF_ENUMERATED.elements;
@@ -4333,6 +4615,14 @@ Enum0_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Enum0_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Enum0_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Enum0] >>> ***/
 
@@ -4369,6 +4659,7 @@ asn_TYPE_descriptor_t asn_DEF_Enum0 = {
 	Enum0_decode_xer,
 	Enum0_encode_xer,
 	Enum0_decode_uper,
+	Enum0_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Enum0_tags_1,
 	sizeof(asn_DEF_Enum0_tags_1)
@@ -4408,6 +4699,7 @@ 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;
+per_type_encoder_f Enum1_encode_uper;
 
 /*** <<< CODE [Enum1] >>> ***/
 
@@ -4449,6 +4741,7 @@ Enum1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
 	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
 	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
 	td->elements       = asn_DEF_NativeEnumerated.elements;
@@ -4507,6 +4800,14 @@ Enum1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Enum1_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Enum1] >>> ***/
 
@@ -4543,6 +4844,7 @@ asn_TYPE_descriptor_t asn_DEF_Enum1 = {
 	Enum1_decode_xer,
 	Enum1_encode_xer,
 	Enum1_decode_uper,
+	Enum1_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Enum1_tags_1,
 	sizeof(asn_DEF_Enum1_tags_1)
@@ -4575,6 +4877,7 @@ 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;
+per_type_encoder_f Identifier_encode_uper;
 
 /*** <<< CTABLES [Identifier] >>> ***/
 
@@ -4646,6 +4949,7 @@ Identifier_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
 	td->xer_decoder    = asn_DEF_VisibleString.xer_decoder;
 	td->xer_encoder    = asn_DEF_VisibleString.xer_encoder;
 	td->uper_decoder   = asn_DEF_VisibleString.uper_decoder;
+	td->uper_encoder   = asn_DEF_VisibleString.uper_encoder;
 	if(!td->per_constraints)
 		td->per_constraints = asn_DEF_VisibleString.per_constraints;
 	td->elements       = asn_DEF_VisibleString.elements;
@@ -4704,6 +5008,14 @@ Identifier_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td
 	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
 }
 
+asn_enc_rval_t
+Identifier_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Identifier_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
 
 /*** <<< STAT-DEFS [Identifier] >>> ***/
 
@@ -4725,6 +5037,7 @@ asn_TYPE_descriptor_t asn_DEF_Identifier = {
 	Identifier_decode_xer,
 	Identifier_encode_xer,
 	Identifier_decode_uper,
+	Identifier_encode_uper,
 	0,	/* Use generic outmost tag fetcher */
 	asn_DEF_Identifier_tags_1,
 	sizeof(asn_DEF_Identifier_tags_1)