verify value range constraints for OER

tests/138-oer-constraints-OK.asn1

+
+-- OK: Everything is fine
+
+-- iso.org.dod.internet.private.enterprise (1.3.6.1.4.1)
+-- .spelio.software.asn1c.test (9363.1.5.1)
+-- .138
+
+ModuleOERConstraints
+	{ iso org(3) dod(6) internet (1) private(4) enterprise(1)
+		spelio(9363) software(1) asn1c(5) test(1) 138 }
+	DEFINITIONS IMPLICIT TAGS ::=
+BEGIN
+
+    A-noc ::= INTEGER                           -- No constraints
+    B-vis ::= INTEGER (0)                       -- Value constraint
+    C-vis ::= INTEGER (-1..1)                   -- Value range constraint
+    D-inv ::= INTEGER (0..10,...)               -- Extensible, not OER-visible
+    E-vis ::= INTEGER (0..10,...)(2..5)         -- OER-visible constraint 2..5
+    F-inv ::= INTEGER (0..10,...)(2..5,...)     -- Not OER-visible
+    G-vis ::= INTEGER (0..10,...)(2..5,...)(3)  -- OER-visible constraint 3
+
+END

tests/138-oer-constraints-OK.asn1.-Pgen-OER

+
+/*** <<< INCLUDES [A-noc] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [A-noc] >>> ***/
+
+typedef long	 A_noc_t;
+
+/*** <<< FUNC-DECLS [A-noc] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_A_noc;
+asn_struct_free_f A_noc_free;
+asn_struct_print_f A_noc_print;
+asn_constr_check_f A_noc_constraint;
+ber_type_decoder_f A_noc_decode_ber;
+der_type_encoder_f A_noc_encode_der;
+xer_type_decoder_f A_noc_decode_xer;
+xer_type_encoder_f A_noc_encode_xer;
+oer_type_decoder_f A_noc_decode_oer;
+oer_type_encoder_f A_noc_encode_oer;
+
+/*** <<< CODE [A-noc] >>> ***/
+
+int
+A_noc_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+A_noc_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->oer_decoder    = asn_DEF_NativeInteger.oer_decoder;
+	td->oer_encoder    = asn_DEF_NativeInteger.oer_encoder;
+	if(!td->oer_constraints)
+		td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+	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
+A_noc_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	A_noc_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+A_noc_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	A_noc_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+A_noc_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) {
+	A_noc_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+A_noc_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) {
+	A_noc_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+A_noc_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) {
+	A_noc_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+A_noc_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) {
+	A_noc_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+A_noc_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+	A_noc_1_inherit_TYPE_descriptor(td);
+	return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+A_noc_encode_oer(asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints,
+		void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+	A_noc_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [A-noc] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_A_noc_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_A_noc = {
+	"A-noc",
+	"A-noc",
+	A_noc_free,
+	A_noc_print,
+	A_noc_constraint,
+	A_noc_decode_ber,
+	A_noc_encode_der,
+	A_noc_decode_xer,
+	A_noc_encode_xer,
+	A_noc_decode_oer,
+	A_noc_encode_oer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_A_noc_tags_1,
+	sizeof(asn_DEF_A_noc_tags_1)
+		/sizeof(asn_DEF_A_noc_tags_1[0]), /* 1 */
+	asn_DEF_A_noc_tags_1,	/* Same as above */
+	sizeof(asn_DEF_A_noc_tags_1)
+		/sizeof(asn_DEF_A_noc_tags_1[0]), /* 1 */
+	0,	/* No OER visible constraints */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [B-vis] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [B-vis] >>> ***/
+
+typedef long	 B_vis_t;
+
+/*** <<< FUNC-DECLS [B-vis] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_B_vis;
+asn_struct_free_f B_vis_free;
+asn_struct_print_f B_vis_print;
+asn_constr_check_f B_vis_constraint;
+ber_type_decoder_f B_vis_decode_ber;
+der_type_encoder_f B_vis_encode_der;
+xer_type_decoder_f B_vis_decode_xer;
+xer_type_encoder_f B_vis_encode_xer;
+oer_type_decoder_f B_vis_decode_oer;
+oer_type_encoder_f B_vis_encode_oer;
+
+/*** <<< CODE [B-vis] >>> ***/
+
+int
+B_vis_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%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__CTFAIL(app_key, td, sptr,
+			"%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
+B_vis_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->oer_decoder    = asn_DEF_NativeInteger.oer_decoder;
+	td->oer_encoder    = asn_DEF_NativeInteger.oer_encoder;
+	if(!td->oer_constraints)
+		td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+	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
+B_vis_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	B_vis_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+B_vis_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	B_vis_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+B_vis_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) {
+	B_vis_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+B_vis_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) {
+	B_vis_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+B_vis_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) {
+	B_vis_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+B_vis_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) {
+	B_vis_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+B_vis_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+	B_vis_1_inherit_TYPE_descriptor(td);
+	return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+B_vis_encode_oer(asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints,
+		void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+	B_vis_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [B-vis] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_B_vis_constr_1 GCC_NOTUSED = {
+	{ AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 0, 0 }	/* (0..0) */,
+	{ 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [B-vis] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_B_vis_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_B_vis = {
+	"B-vis",
+	"B-vis",
+	B_vis_free,
+	B_vis_print,
+	B_vis_constraint,
+	B_vis_decode_ber,
+	B_vis_encode_der,
+	B_vis_decode_xer,
+	B_vis_encode_xer,
+	B_vis_decode_oer,
+	B_vis_encode_oer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_B_vis_tags_1,
+	sizeof(asn_DEF_B_vis_tags_1)
+		/sizeof(asn_DEF_B_vis_tags_1[0]), /* 1 */
+	asn_DEF_B_vis_tags_1,	/* Same as above */
+	sizeof(asn_DEF_B_vis_tags_1)
+		/sizeof(asn_DEF_B_vis_tags_1[0]), /* 1 */
+	&asn_OER_type_B_vis_constr_1,
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [C-vis] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [C-vis] >>> ***/
+
+typedef long	 C_vis_t;
+
+/*** <<< FUNC-DECLS [C-vis] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_C_vis;
+asn_struct_free_f C_vis_free;
+asn_struct_print_f C_vis_print;
+asn_constr_check_f C_vis_constraint;
+ber_type_decoder_f C_vis_decode_ber;
+der_type_encoder_f C_vis_encode_der;
+xer_type_decoder_f C_vis_decode_xer;
+xer_type_encoder_f C_vis_encode_xer;
+oer_type_decoder_f C_vis_decode_oer;
+oer_type_encoder_f C_vis_encode_oer;
+
+/*** <<< CODE [C-vis] >>> ***/
+
+int
+C_vis_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= -1 && value <= 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%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
+C_vis_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->oer_decoder    = asn_DEF_NativeInteger.oer_decoder;
+	td->oer_encoder    = asn_DEF_NativeInteger.oer_encoder;
+	if(!td->oer_constraints)
+		td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+	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
+C_vis_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	C_vis_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+C_vis_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	C_vis_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+C_vis_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) {
+	C_vis_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+C_vis_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) {
+	C_vis_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+C_vis_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) {
+	C_vis_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+C_vis_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) {
+	C_vis_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+C_vis_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+	C_vis_1_inherit_TYPE_descriptor(td);
+	return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+C_vis_encode_oer(asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints,
+		void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+	C_vis_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [C-vis] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_C_vis_constr_1 GCC_NOTUSED = {
+	{ AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, -1, 1 }	/* (-1..1) */,
+	{ 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [C-vis] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_C_vis_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_C_vis = {
+	"C-vis",
+	"C-vis",
+	C_vis_free,
+	C_vis_print,
+	C_vis_constraint,
+	C_vis_decode_ber,
+	C_vis_encode_der,
+	C_vis_decode_xer,
+	C_vis_encode_xer,
+	C_vis_decode_oer,
+	C_vis_encode_oer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_C_vis_tags_1,
+	sizeof(asn_DEF_C_vis_tags_1)
+		/sizeof(asn_DEF_C_vis_tags_1[0]), /* 1 */
+	asn_DEF_C_vis_tags_1,	/* Same as above */
+	sizeof(asn_DEF_C_vis_tags_1)
+		/sizeof(asn_DEF_C_vis_tags_1[0]), /* 1 */
+	&asn_OER_type_C_vis_constr_1,
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [D-inv] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [D-inv] >>> ***/
+
+typedef long	 D_inv_t;
+
+/*** <<< FUNC-DECLS [D-inv] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_D_inv;
+asn_struct_free_f D_inv_free;
+asn_struct_print_f D_inv_print;
+asn_constr_check_f D_inv_constraint;
+ber_type_decoder_f D_inv_decode_ber;
+der_type_encoder_f D_inv_encode_der;
+xer_type_decoder_f D_inv_decode_xer;
+xer_type_encoder_f D_inv_encode_xer;
+oer_type_decoder_f D_inv_decode_oer;
+oer_type_encoder_f D_inv_encode_oer;
+
+/*** <<< CODE [D-inv] >>> ***/
+
+int
+D_inv_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 10)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%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
+D_inv_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->oer_decoder    = asn_DEF_NativeInteger.oer_decoder;
+	td->oer_encoder    = asn_DEF_NativeInteger.oer_encoder;
+	if(!td->oer_constraints)
+		td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+	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
+D_inv_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	D_inv_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+D_inv_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	D_inv_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+D_inv_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) {
+	D_inv_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+D_inv_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) {
+	D_inv_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+D_inv_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) {
+	D_inv_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+D_inv_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) {
+	D_inv_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+D_inv_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+	D_inv_1_inherit_TYPE_descriptor(td);
+	return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+D_inv_encode_oer(asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints,
+		void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+	D_inv_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [D-inv] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_D_inv_constr_1 GCC_NOTUSED = {
+	{ AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 0, 10 }	/* (0..10,...) */,
+	{ 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [D-inv] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_D_inv_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_D_inv = {
+	"D-inv",
+	"D-inv",
+	D_inv_free,
+	D_inv_print,
+	D_inv_constraint,
+	D_inv_decode_ber,
+	D_inv_encode_der,
+	D_inv_decode_xer,
+	D_inv_encode_xer,
+	D_inv_decode_oer,
+	D_inv_encode_oer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_D_inv_tags_1,
+	sizeof(asn_DEF_D_inv_tags_1)
+		/sizeof(asn_DEF_D_inv_tags_1[0]), /* 1 */
+	asn_DEF_D_inv_tags_1,	/* Same as above */
+	sizeof(asn_DEF_D_inv_tags_1)
+		/sizeof(asn_DEF_D_inv_tags_1[0]), /* 1 */
+	&asn_OER_type_D_inv_constr_1,
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [E-vis] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [E-vis] >>> ***/
+
+typedef long	 E_vis_t;
+
+/*** <<< FUNC-DECLS [E-vis] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_E_vis;
+asn_struct_free_f E_vis_free;
+asn_struct_print_f E_vis_print;
+asn_constr_check_f E_vis_constraint;
+ber_type_decoder_f E_vis_decode_ber;
+der_type_encoder_f E_vis_encode_der;
+xer_type_decoder_f E_vis_decode_xer;
+xer_type_encoder_f E_vis_encode_xer;
+oer_type_decoder_f E_vis_decode_oer;
+oer_type_encoder_f E_vis_encode_oer;
+
+/*** <<< CODE [E-vis] >>> ***/
+
+int
+E_vis_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 2 && value <= 5)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%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
+E_vis_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->oer_decoder    = asn_DEF_NativeInteger.oer_decoder;
+	td->oer_encoder    = asn_DEF_NativeInteger.oer_encoder;
+	if(!td->oer_constraints)
+		td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+	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
+E_vis_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	E_vis_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+E_vis_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	E_vis_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+E_vis_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) {
+	E_vis_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+E_vis_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) {
+	E_vis_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+E_vis_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) {
+	E_vis_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+E_vis_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) {
+	E_vis_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+E_vis_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+	E_vis_1_inherit_TYPE_descriptor(td);
+	return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+E_vis_encode_oer(asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints,
+		void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+	E_vis_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [E-vis] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_E_vis_constr_1 GCC_NOTUSED = {
+	{ AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 2, 5 }	/* (2..5) */,
+	{ 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [E-vis] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_E_vis_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_E_vis = {
+	"E-vis",
+	"E-vis",
+	E_vis_free,
+	E_vis_print,
+	E_vis_constraint,
+	E_vis_decode_ber,
+	E_vis_encode_der,
+	E_vis_decode_xer,
+	E_vis_encode_xer,
+	E_vis_decode_oer,
+	E_vis_encode_oer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_E_vis_tags_1,
+	sizeof(asn_DEF_E_vis_tags_1)
+		/sizeof(asn_DEF_E_vis_tags_1[0]), /* 1 */
+	asn_DEF_E_vis_tags_1,	/* Same as above */
+	sizeof(asn_DEF_E_vis_tags_1)
+		/sizeof(asn_DEF_E_vis_tags_1[0]), /* 1 */
+	&asn_OER_type_E_vis_constr_1,
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [F-inv] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [F-inv] >>> ***/
+
+typedef long	 F_inv_t;
+
+/*** <<< FUNC-DECLS [F-inv] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_F_inv;
+asn_struct_free_f F_inv_free;
+asn_struct_print_f F_inv_print;
+asn_constr_check_f F_inv_constraint;
+ber_type_decoder_f F_inv_decode_ber;
+der_type_encoder_f F_inv_encode_der;
+xer_type_decoder_f F_inv_decode_xer;
+xer_type_encoder_f F_inv_encode_xer;
+oer_type_decoder_f F_inv_decode_oer;
+oer_type_encoder_f F_inv_encode_oer;
+
+/*** <<< CODE [F-inv] >>> ***/
+
+int
+F_inv_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 2 && value <= 5)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%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
+F_inv_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->oer_decoder    = asn_DEF_NativeInteger.oer_decoder;
+	td->oer_encoder    = asn_DEF_NativeInteger.oer_encoder;
+	if(!td->oer_constraints)
+		td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+	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
+F_inv_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	F_inv_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+F_inv_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	F_inv_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+F_inv_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) {
+	F_inv_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+F_inv_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) {
+	F_inv_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+F_inv_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) {
+	F_inv_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+F_inv_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) {
+	F_inv_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+F_inv_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+	F_inv_1_inherit_TYPE_descriptor(td);
+	return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+F_inv_encode_oer(asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints,
+		void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+	F_inv_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [F-inv] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_F_inv_constr_1 GCC_NOTUSED = {
+	{ AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 2, 5 }	/* (2..5,...) */,
+	{ 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [F-inv] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_F_inv_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_F_inv = {
+	"F-inv",
+	"F-inv",
+	F_inv_free,
+	F_inv_print,
+	F_inv_constraint,
+	F_inv_decode_ber,
+	F_inv_encode_der,
+	F_inv_decode_xer,
+	F_inv_encode_xer,
+	F_inv_decode_oer,
+	F_inv_encode_oer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_F_inv_tags_1,
+	sizeof(asn_DEF_F_inv_tags_1)
+		/sizeof(asn_DEF_F_inv_tags_1[0]), /* 1 */
+	asn_DEF_F_inv_tags_1,	/* Same as above */
+	sizeof(asn_DEF_F_inv_tags_1)
+		/sizeof(asn_DEF_F_inv_tags_1[0]), /* 1 */
+	&asn_OER_type_F_inv_constr_1,
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+
+/*** <<< INCLUDES [G-vis] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [G-vis] >>> ***/
+
+typedef long	 G_vis_t;
+
+/*** <<< FUNC-DECLS [G-vis] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_G_vis;
+asn_struct_free_f G_vis_free;
+asn_struct_print_f G_vis_print;
+asn_constr_check_f G_vis_constraint;
+ber_type_decoder_f G_vis_decode_ber;
+der_type_encoder_f G_vis_encode_der;
+xer_type_decoder_f G_vis_decode_xer;
+xer_type_encoder_f G_vis_encode_xer;
+oer_type_decoder_f G_vis_decode_oer;
+oer_type_encoder_f G_vis_encode_oer;
+
+/*** <<< CODE [G-vis] >>> ***/
+
+int
+G_vis_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value == 3)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%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
+G_vis_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->oer_decoder    = asn_DEF_NativeInteger.oer_decoder;
+	td->oer_encoder    = asn_DEF_NativeInteger.oer_encoder;
+	if(!td->oer_constraints)
+		td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+	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
+G_vis_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	G_vis_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+G_vis_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	G_vis_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+G_vis_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) {
+	G_vis_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+G_vis_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) {
+	G_vis_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+G_vis_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) {
+	G_vis_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+G_vis_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) {
+	G_vis_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+G_vis_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+	G_vis_1_inherit_TYPE_descriptor(td);
+	return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+G_vis_encode_oer(asn_TYPE_descriptor_t *td,
+		asn_oer_constraints_t *constraints,
+		void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+	G_vis_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [G-vis] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_G_vis_constr_1 GCC_NOTUSED = {
+	{ AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 3, 3 }	/* (3..3) */,
+	{ 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [G-vis] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_G_vis_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_G_vis = {
+	"G-vis",
+	"G-vis",
+	G_vis_free,
+	G_vis_print,
+	G_vis_constraint,
+	G_vis_decode_ber,
+	G_vis_encode_der,
+	G_vis_decode_xer,
+	G_vis_encode_xer,
+	G_vis_decode_oer,
+	G_vis_encode_oer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_G_vis_tags_1,
+	sizeof(asn_DEF_G_vis_tags_1)
+		/sizeof(asn_DEF_G_vis_tags_1[0]), /* 1 */
+	asn_DEF_G_vis_tags_1,	/* Same as above */
+	sizeof(asn_DEF_G_vis_tags_1)
+		/sizeof(asn_DEF_G_vis_tags_1[0]), /* 1 */
+	&asn_OER_type_G_vis_constr_1,
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+