Blame - tests/90-cond-int-type-OK.asn1.-Pfnative-types - asn1c

blob: 7aebc66c3d71c6f2ffa195e53fe5fbea0fe465fc [file] [log] [blame]

Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame^]	1
				2	/* <<< INCLUDES [CN-IntegerUnlimited] >>> */
				3
				4	#include <NativeInteger.h>
				5
				6	/* <<< TYPE-DECLS [CN-IntegerUnlimited] >>> */
				7
				8	typedef long CN_IntegerUnlimited_t;
				9
				10	/* <<< FUNC-DECLS [CN-IntegerUnlimited] >>> */
				11
				12	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited;
				13	asn_struct_free_f CN_IntegerUnlimited_free;
				14	asn_struct_print_f CN_IntegerUnlimited_print;
				15	asn_constr_check_f CN_IntegerUnlimited_constraint;
				16	ber_type_decoder_f CN_IntegerUnlimited_decode_ber;
				17	der_type_encoder_f CN_IntegerUnlimited_encode_der;
				18	xer_type_decoder_f CN_IntegerUnlimited_decode_xer;
				19	xer_type_encoder_f CN_IntegerUnlimited_encode_xer;
				20
				21	/* <<< CODE [CN-IntegerUnlimited] >>> */
				22
				23	int
				24	CN_IntegerUnlimited_constraint(asn_TYPE_descriptor_t td, const void sptr,
				25	asn_app_consume_bytes_f app_errlog, void app_key) {
				26	/* Replace with underlying type checker */
				27	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
				28	return td->check_constraints(td, sptr, app_errlog, app_key);
				29	}
				30
				31	/*
				32	* This type is implemented using NativeInteger,
				33	* so here we adjust the DEF accordingly.
				34	*/
				35	static void
				36	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				37	td->free_struct = asn_DEF_NativeInteger.free_struct;
				38	td->print_struct = asn_DEF_NativeInteger.print_struct;
				39	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				40	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				41	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				42	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				43	td->elements = asn_DEF_NativeInteger.elements;
				44	td->elements_count = asn_DEF_NativeInteger.elements_count;
				45	td->specifics = asn_DEF_NativeInteger.specifics;
				46	}
				47
				48	void
				49	CN_IntegerUnlimited_free(asn_TYPE_descriptor_t *td,
				50	void *struct_ptr, int contents_only) {
				51	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				52	td->free_struct(td, struct_ptr, contents_only);
				53	}
				54
				55	int
				56	CN_IntegerUnlimited_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				57	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				58	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				59	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				60	}
				61
				62	asn_dec_rval_t
				63	CN_IntegerUnlimited_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				64	void *structure, const void bufptr, size_t size, int tag_mode) {
				65	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				66	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				67	}
				68
				69	asn_enc_rval_t
				70	CN_IntegerUnlimited_encode_der(asn_TYPE_descriptor_t *td,
				71	void *structure, int tag_mode, ber_tlv_tag_t tag,
				72	asn_app_consume_bytes_f cb, void app_key) {
				73	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				74	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				75	}
				76
				77	asn_dec_rval_t
				78	CN_IntegerUnlimited_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				79	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				80	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				81	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				82	}
				83
				84	asn_enc_rval_t
				85	CN_IntegerUnlimited_encode_xer(asn_TYPE_descriptor_t td, void structure,
				86	int ilevel, enum xer_encoder_flags_e flags,
				87	asn_app_consume_bytes_f cb, void app_key) {
				88	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				89	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				90	}
				91
				92
				93	/* <<< STAT-DEFS [CN-IntegerUnlimited] >>> */
				94
				95	static ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_1_tags[] = {
				96	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				97	};
				98	asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited = {
				99	"CN-IntegerUnlimited",
				100	"CN-IntegerUnlimited",
				101	CN_IntegerUnlimited_free,
				102	CN_IntegerUnlimited_print,
				103	CN_IntegerUnlimited_constraint,
				104	CN_IntegerUnlimited_decode_ber,
				105	CN_IntegerUnlimited_encode_der,
				106	CN_IntegerUnlimited_decode_xer,
				107	CN_IntegerUnlimited_encode_xer,
				108	0, /* Use generic outmost tag fetcher */
				109	asn_DEF_CN_IntegerUnlimited_1_tags,
				110	sizeof(asn_DEF_CN_IntegerUnlimited_1_tags)
				111	/sizeof(asn_DEF_CN_IntegerUnlimited_1_tags[0]), /* 1 */
				112	asn_DEF_CN_IntegerUnlimited_1_tags, /* Same as above */
				113	sizeof(asn_DEF_CN_IntegerUnlimited_1_tags)
				114	/sizeof(asn_DEF_CN_IntegerUnlimited_1_tags[0]), /* 1 */
				115	0, 0, /* No members */
				116	0 /* No specifics */
				117	};
				118
				119
				120	/* <<< INCLUDES [CN-IntegerMinMax] >>> */
				121
				122	#include <NativeInteger.h>
				123
				124	/* <<< TYPE-DECLS [CN-IntegerMinMax] >>> */
				125
				126	typedef long CN_IntegerMinMax_t;
				127
				128	/* <<< FUNC-DECLS [CN-IntegerMinMax] >>> */
				129
				130	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax;
				131	asn_struct_free_f CN_IntegerMinMax_free;
				132	asn_struct_print_f CN_IntegerMinMax_print;
				133	asn_constr_check_f CN_IntegerMinMax_constraint;
				134	ber_type_decoder_f CN_IntegerMinMax_decode_ber;
				135	der_type_encoder_f CN_IntegerMinMax_encode_der;
				136	xer_type_decoder_f CN_IntegerMinMax_decode_xer;
				137	xer_type_encoder_f CN_IntegerMinMax_encode_xer;
				138
				139	/* <<< CODE [CN-IntegerMinMax] >>> */
				140
				141	int
				142	CN_IntegerMinMax_constraint(asn_TYPE_descriptor_t td, const void sptr,
				143	asn_app_consume_bytes_f app_errlog, void app_key) {
				144
				145	if(!sptr) {
				146	_ASN_ERRLOG(app_errlog, app_key,
				147	"%s: value not given (%s:%d)",
				148	td->name, __FILE__, __LINE__);
				149	return -1;
				150	}
				151
				152
				153	if(1 /* No applicable constraints whatsoever */) {
				154	/* Nothing is here. See below */
				155	}
				156
				157	/* Replace with underlying type checker */
				158	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
				159	return td->check_constraints(td, sptr, app_errlog, app_key);
				160	}
				161
				162	/*
				163	* This type is implemented using NativeInteger,
				164	* so here we adjust the DEF accordingly.
				165	*/
				166	static void
				167	CN_IntegerMinMax_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				168	td->free_struct = asn_DEF_NativeInteger.free_struct;
				169	td->print_struct = asn_DEF_NativeInteger.print_struct;
				170	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				171	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				172	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				173	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				174	td->elements = asn_DEF_NativeInteger.elements;
				175	td->elements_count = asn_DEF_NativeInteger.elements_count;
				176	td->specifics = asn_DEF_NativeInteger.specifics;
				177	}
				178
				179	void
				180	CN_IntegerMinMax_free(asn_TYPE_descriptor_t *td,
				181	void *struct_ptr, int contents_only) {
				182	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				183	td->free_struct(td, struct_ptr, contents_only);
				184	}
				185
				186	int
				187	CN_IntegerMinMax_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				188	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				189	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				190	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				191	}
				192
				193	asn_dec_rval_t
				194	CN_IntegerMinMax_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				195	void *structure, const void bufptr, size_t size, int tag_mode) {
				196	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				197	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				198	}
				199
				200	asn_enc_rval_t
				201	CN_IntegerMinMax_encode_der(asn_TYPE_descriptor_t *td,
				202	void *structure, int tag_mode, ber_tlv_tag_t tag,
				203	asn_app_consume_bytes_f cb, void app_key) {
				204	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				205	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				206	}
				207
				208	asn_dec_rval_t
				209	CN_IntegerMinMax_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				210	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				211	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				212	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				213	}
				214
				215	asn_enc_rval_t
				216	CN_IntegerMinMax_encode_xer(asn_TYPE_descriptor_t td, void structure,
				217	int ilevel, enum xer_encoder_flags_e flags,
				218	asn_app_consume_bytes_f cb, void app_key) {
				219	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				220	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				221	}
				222
				223
				224	/* <<< STAT-DEFS [CN-IntegerMinMax] >>> */
				225
				226	static ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_1_tags[] = {
				227	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				228	};
				229	asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax = {
				230	"CN-IntegerMinMax",
				231	"CN-IntegerMinMax",
				232	CN_IntegerMinMax_free,
				233	CN_IntegerMinMax_print,
				234	CN_IntegerMinMax_constraint,
				235	CN_IntegerMinMax_decode_ber,
				236	CN_IntegerMinMax_encode_der,
				237	CN_IntegerMinMax_decode_xer,
				238	CN_IntegerMinMax_encode_xer,
				239	0, /* Use generic outmost tag fetcher */
				240	asn_DEF_CN_IntegerMinMax_1_tags,
				241	sizeof(asn_DEF_CN_IntegerMinMax_1_tags)
				242	/sizeof(asn_DEF_CN_IntegerMinMax_1_tags[0]), /* 1 */
				243	asn_DEF_CN_IntegerMinMax_1_tags, /* Same as above */
				244	sizeof(asn_DEF_CN_IntegerMinMax_1_tags)
				245	/sizeof(asn_DEF_CN_IntegerMinMax_1_tags[0]), /* 1 */
				246	0, 0, /* No members */
				247	0 /* No specifics */
				248	};
				249
				250
				251	/* <<< INCLUDES [CN-IntegerMinLow] >>> */
				252
				253	#include <INTEGER.h>
				254
				255	/* <<< TYPE-DECLS [CN-IntegerMinLow] >>> */
				256
				257	typedef INTEGER_t CN_IntegerMinLow_t;
				258
				259	/* <<< FUNC-DECLS [CN-IntegerMinLow] >>> */
				260
				261	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow;
				262	asn_struct_free_f CN_IntegerMinLow_free;
				263	asn_struct_print_f CN_IntegerMinLow_print;
				264	asn_constr_check_f CN_IntegerMinLow_constraint;
				265	ber_type_decoder_f CN_IntegerMinLow_decode_ber;
				266	der_type_encoder_f CN_IntegerMinLow_encode_der;
				267	xer_type_decoder_f CN_IntegerMinLow_decode_xer;
				268	xer_type_encoder_f CN_IntegerMinLow_encode_xer;
				269
				270	/* <<< CODE [CN-IntegerMinLow] >>> */
				271
				272	int
				273	CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t td, const void sptr,
				274	asn_app_consume_bytes_f app_errlog, void app_key) {
				275	const INTEGER_t st = (const INTEGER_t )sptr;
				276	long value;
				277
				278	if(!sptr) {
				279	_ASN_ERRLOG(app_errlog, app_key,
				280	"%s: value not given (%s:%d)",
				281	td->name, __FILE__, __LINE__);
				282	return -1;
				283	}
				284
				285	if(asn_INTEGER2long(st, &value)) {
				286	_ASN_ERRLOG(app_errlog, app_key,
				287	"%s: value too large (%s:%d)",
				288	td->name, __FILE__, __LINE__);
				289	return -1;
				290	}
				291
				292	if((value <= 1)) {
				293	/* Constraint check succeeded */
				294	return 0;
				295	} else {
				296	_ASN_ERRLOG(app_errlog, app_key,
				297	"%s: constraint failed (%s:%d)",
				298	td->name, __FILE__, __LINE__);
				299	return -1;
				300	}
				301	}
				302
				303	/*
				304	* This type is implemented using INTEGER,
				305	* so here we adjust the DEF accordingly.
				306	*/
				307	static void
				308	CN_IntegerMinLow_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				309	td->free_struct = asn_DEF_INTEGER.free_struct;
				310	td->print_struct = asn_DEF_INTEGER.print_struct;
				311	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				312	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				313	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				314	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				315	td->elements = asn_DEF_INTEGER.elements;
				316	td->elements_count = asn_DEF_INTEGER.elements_count;
				317	td->specifics = asn_DEF_INTEGER.specifics;
				318	}
				319
				320	void
				321	CN_IntegerMinLow_free(asn_TYPE_descriptor_t *td,
				322	void *struct_ptr, int contents_only) {
				323	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				324	td->free_struct(td, struct_ptr, contents_only);
				325	}
				326
				327	int
				328	CN_IntegerMinLow_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				329	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				330	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				331	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				332	}
				333
				334	asn_dec_rval_t
				335	CN_IntegerMinLow_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				336	void *structure, const void bufptr, size_t size, int tag_mode) {
				337	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				338	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				339	}
				340
				341	asn_enc_rval_t
				342	CN_IntegerMinLow_encode_der(asn_TYPE_descriptor_t *td,
				343	void *structure, int tag_mode, ber_tlv_tag_t tag,
				344	asn_app_consume_bytes_f cb, void app_key) {
				345	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				346	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				347	}
				348
				349	asn_dec_rval_t
				350	CN_IntegerMinLow_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				351	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				352	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				353	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				354	}
				355
				356	asn_enc_rval_t
				357	CN_IntegerMinLow_encode_xer(asn_TYPE_descriptor_t td, void structure,
				358	int ilevel, enum xer_encoder_flags_e flags,
				359	asn_app_consume_bytes_f cb, void app_key) {
				360	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				361	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				362	}
				363
				364
				365	/* <<< STAT-DEFS [CN-IntegerMinLow] >>> */
				366
				367	static ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_1_tags[] = {
				368	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				369	};
				370	asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow = {
				371	"CN-IntegerMinLow",
				372	"CN-IntegerMinLow",
				373	CN_IntegerMinLow_free,
				374	CN_IntegerMinLow_print,
				375	CN_IntegerMinLow_constraint,
				376	CN_IntegerMinLow_decode_ber,
				377	CN_IntegerMinLow_encode_der,
				378	CN_IntegerMinLow_decode_xer,
				379	CN_IntegerMinLow_encode_xer,
				380	0, /* Use generic outmost tag fetcher */
				381	asn_DEF_CN_IntegerMinLow_1_tags,
				382	sizeof(asn_DEF_CN_IntegerMinLow_1_tags)
				383	/sizeof(asn_DEF_CN_IntegerMinLow_1_tags[0]), /* 1 */
				384	asn_DEF_CN_IntegerMinLow_1_tags, /* Same as above */
				385	sizeof(asn_DEF_CN_IntegerMinLow_1_tags)
				386	/sizeof(asn_DEF_CN_IntegerMinLow_1_tags[0]), /* 1 */
				387	0, 0, /* No members */
				388	0 /* No specifics */
				389	};
				390
				391
				392	/* <<< INCLUDES [NO-IntegerMinHigh] >>> */
				393
				394	#include <INTEGER.h>
				395
				396	/* <<< TYPE-DECLS [NO-IntegerMinHigh] >>> */
				397
				398	typedef INTEGER_t NO_IntegerMinHigh_t;
				399
				400	/* <<< FUNC-DECLS [NO-IntegerMinHigh] >>> */
				401
				402	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh;
				403	asn_struct_free_f NO_IntegerMinHigh_free;
				404	asn_struct_print_f NO_IntegerMinHigh_print;
				405	asn_constr_check_f NO_IntegerMinHigh_constraint;
				406	ber_type_decoder_f NO_IntegerMinHigh_decode_ber;
				407	der_type_encoder_f NO_IntegerMinHigh_encode_der;
				408	xer_type_decoder_f NO_IntegerMinHigh_decode_xer;
				409	xer_type_encoder_f NO_IntegerMinHigh_encode_xer;
				410
				411	/* <<< CODE [NO-IntegerMinHigh] >>> */
				412
				413	int
				414	NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t td, const void sptr,
				415	asn_app_consume_bytes_f app_errlog, void app_key) {
				416	const INTEGER_t st = (const INTEGER_t )sptr;
				417	long value;
				418
				419	if(!sptr) {
				420	_ASN_ERRLOG(app_errlog, app_key,
				421	"%s: value not given (%s:%d)",
				422	td->name, __FILE__, __LINE__);
				423	return -1;
				424	}
				425
				426	if(asn_INTEGER2long(st, &value)) {
				427	_ASN_ERRLOG(app_errlog, app_key,
				428	"%s: value too large (%s:%d)",
				429	td->name, __FILE__, __LINE__);
				430	return -1;
				431	}
				432
				433	if((value <= 5000000000)) {
				434	/* Constraint check succeeded */
				435	return 0;
				436	} else {
				437	_ASN_ERRLOG(app_errlog, app_key,
				438	"%s: constraint failed (%s:%d)",
				439	td->name, __FILE__, __LINE__);
				440	return -1;
				441	}
				442	}
				443
				444	/*
				445	* This type is implemented using INTEGER,
				446	* so here we adjust the DEF accordingly.
				447	*/
				448	static void
				449	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				450	td->free_struct = asn_DEF_INTEGER.free_struct;
				451	td->print_struct = asn_DEF_INTEGER.print_struct;
				452	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				453	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				454	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				455	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				456	td->elements = asn_DEF_INTEGER.elements;
				457	td->elements_count = asn_DEF_INTEGER.elements_count;
				458	td->specifics = asn_DEF_INTEGER.specifics;
				459	}
				460
				461	void
				462	NO_IntegerMinHigh_free(asn_TYPE_descriptor_t *td,
				463	void *struct_ptr, int contents_only) {
				464	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				465	td->free_struct(td, struct_ptr, contents_only);
				466	}
				467
				468	int
				469	NO_IntegerMinHigh_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				470	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				471	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				472	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				473	}
				474
				475	asn_dec_rval_t
				476	NO_IntegerMinHigh_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				477	void *structure, const void bufptr, size_t size, int tag_mode) {
				478	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				479	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				480	}
				481
				482	asn_enc_rval_t
				483	NO_IntegerMinHigh_encode_der(asn_TYPE_descriptor_t *td,
				484	void *structure, int tag_mode, ber_tlv_tag_t tag,
				485	asn_app_consume_bytes_f cb, void app_key) {
				486	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				487	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				488	}
				489
				490	asn_dec_rval_t
				491	NO_IntegerMinHigh_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				492	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				493	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				494	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				495	}
				496
				497	asn_enc_rval_t
				498	NO_IntegerMinHigh_encode_xer(asn_TYPE_descriptor_t td, void structure,
				499	int ilevel, enum xer_encoder_flags_e flags,
				500	asn_app_consume_bytes_f cb, void app_key) {
				501	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				502	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				503	}
				504
				505
				506	/* <<< STAT-DEFS [NO-IntegerMinHigh] >>> */
				507
				508	static ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_1_tags[] = {
				509	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				510	};
				511	asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
				512	"NO-IntegerMinHigh",
				513	"NO-IntegerMinHigh",
				514	NO_IntegerMinHigh_free,
				515	NO_IntegerMinHigh_print,
				516	NO_IntegerMinHigh_constraint,
				517	NO_IntegerMinHigh_decode_ber,
				518	NO_IntegerMinHigh_encode_der,
				519	NO_IntegerMinHigh_decode_xer,
				520	NO_IntegerMinHigh_encode_xer,
				521	0, /* Use generic outmost tag fetcher */
				522	asn_DEF_NO_IntegerMinHigh_1_tags,
				523	sizeof(asn_DEF_NO_IntegerMinHigh_1_tags)
				524	/sizeof(asn_DEF_NO_IntegerMinHigh_1_tags[0]), /* 1 */
				525	asn_DEF_NO_IntegerMinHigh_1_tags, /* Same as above */
				526	sizeof(asn_DEF_NO_IntegerMinHigh_1_tags)
				527	/sizeof(asn_DEF_NO_IntegerMinHigh_1_tags[0]), /* 1 */
				528	0, 0, /* No members */
				529	0 /* No specifics */
				530	};
				531
				532
				533	/* <<< INCLUDES [NO-IntegerLowHigh] >>> */
				534
				535	#include <INTEGER.h>
				536
				537	/* <<< TYPE-DECLS [NO-IntegerLowHigh] >>> */
				538
				539	typedef INTEGER_t NO_IntegerLowHigh_t;
				540
				541	/* <<< FUNC-DECLS [NO-IntegerLowHigh] >>> */
				542
				543	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh;
				544	asn_struct_free_f NO_IntegerLowHigh_free;
				545	asn_struct_print_f NO_IntegerLowHigh_print;
				546	asn_constr_check_f NO_IntegerLowHigh_constraint;
				547	ber_type_decoder_f NO_IntegerLowHigh_decode_ber;
				548	der_type_encoder_f NO_IntegerLowHigh_encode_der;
				549	xer_type_decoder_f NO_IntegerLowHigh_decode_xer;
				550	xer_type_encoder_f NO_IntegerLowHigh_encode_xer;
				551
				552	/* <<< CODE [NO-IntegerLowHigh] >>> */
				553
				554	int
				555	NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t td, const void sptr,
				556	asn_app_consume_bytes_f app_errlog, void app_key) {
				557	const INTEGER_t st = (const INTEGER_t )sptr;
				558	long value;
				559
				560	if(!sptr) {
				561	_ASN_ERRLOG(app_errlog, app_key,
				562	"%s: value not given (%s:%d)",
				563	td->name, __FILE__, __LINE__);
				564	return -1;
				565	}
				566
				567	if(asn_INTEGER2long(st, &value)) {
				568	_ASN_ERRLOG(app_errlog, app_key,
				569	"%s: value too large (%s:%d)",
				570	td->name, __FILE__, __LINE__);
				571	return -1;
				572	}
				573
				574	if((value >= 1 && value <= 5000000000)) {
				575	/* Constraint check succeeded */
				576	return 0;
				577	} else {
				578	_ASN_ERRLOG(app_errlog, app_key,
				579	"%s: constraint failed (%s:%d)",
				580	td->name, __FILE__, __LINE__);
				581	return -1;
				582	}
				583	}
				584
				585	/*
				586	* This type is implemented using INTEGER,
				587	* so here we adjust the DEF accordingly.
				588	*/
				589	static void
				590	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				591	td->free_struct = asn_DEF_INTEGER.free_struct;
				592	td->print_struct = asn_DEF_INTEGER.print_struct;
				593	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				594	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				595	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				596	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				597	td->elements = asn_DEF_INTEGER.elements;
				598	td->elements_count = asn_DEF_INTEGER.elements_count;
				599	td->specifics = asn_DEF_INTEGER.specifics;
				600	}
				601
				602	void
				603	NO_IntegerLowHigh_free(asn_TYPE_descriptor_t *td,
				604	void *struct_ptr, int contents_only) {
				605	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				606	td->free_struct(td, struct_ptr, contents_only);
				607	}
				608
				609	int
				610	NO_IntegerLowHigh_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				611	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				612	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				613	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				614	}
				615
				616	asn_dec_rval_t
				617	NO_IntegerLowHigh_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				618	void *structure, const void bufptr, size_t size, int tag_mode) {
				619	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				620	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				621	}
				622
				623	asn_enc_rval_t
				624	NO_IntegerLowHigh_encode_der(asn_TYPE_descriptor_t *td,
				625	void *structure, int tag_mode, ber_tlv_tag_t tag,
				626	asn_app_consume_bytes_f cb, void app_key) {
				627	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				628	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				629	}
				630
				631	asn_dec_rval_t
				632	NO_IntegerLowHigh_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				633	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				634	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				635	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				636	}
				637
				638	asn_enc_rval_t
				639	NO_IntegerLowHigh_encode_xer(asn_TYPE_descriptor_t td, void structure,
				640	int ilevel, enum xer_encoder_flags_e flags,
				641	asn_app_consume_bytes_f cb, void app_key) {
				642	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				643	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				644	}
				645
				646
				647	/* <<< STAT-DEFS [NO-IntegerLowHigh] >>> */
				648
				649	static ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_1_tags[] = {
				650	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				651	};
				652	asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
				653	"NO-IntegerLowHigh",
				654	"NO-IntegerLowHigh",
				655	NO_IntegerLowHigh_free,
				656	NO_IntegerLowHigh_print,
				657	NO_IntegerLowHigh_constraint,
				658	NO_IntegerLowHigh_decode_ber,
				659	NO_IntegerLowHigh_encode_der,
				660	NO_IntegerLowHigh_decode_xer,
				661	NO_IntegerLowHigh_encode_xer,
				662	0, /* Use generic outmost tag fetcher */
				663	asn_DEF_NO_IntegerLowHigh_1_tags,
				664	sizeof(asn_DEF_NO_IntegerLowHigh_1_tags)
				665	/sizeof(asn_DEF_NO_IntegerLowHigh_1_tags[0]), /* 1 */
				666	asn_DEF_NO_IntegerLowHigh_1_tags, /* Same as above */
				667	sizeof(asn_DEF_NO_IntegerLowHigh_1_tags)
				668	/sizeof(asn_DEF_NO_IntegerLowHigh_1_tags[0]), /* 1 */
				669	0, 0, /* No members */
				670	0 /* No specifics */
				671	};
				672
				673
				674	/* <<< INCLUDES [CN-IntegerLowMax] >>> */
				675
				676	#include <INTEGER.h>
				677
				678	/* <<< TYPE-DECLS [CN-IntegerLowMax] >>> */
				679
				680	typedef INTEGER_t CN_IntegerLowMax_t;
				681
				682	/* <<< FUNC-DECLS [CN-IntegerLowMax] >>> */
				683
				684	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax;
				685	asn_struct_free_f CN_IntegerLowMax_free;
				686	asn_struct_print_f CN_IntegerLowMax_print;
				687	asn_constr_check_f CN_IntegerLowMax_constraint;
				688	ber_type_decoder_f CN_IntegerLowMax_decode_ber;
				689	der_type_encoder_f CN_IntegerLowMax_encode_der;
				690	xer_type_decoder_f CN_IntegerLowMax_decode_xer;
				691	xer_type_encoder_f CN_IntegerLowMax_encode_xer;
				692
				693	/* <<< CODE [CN-IntegerLowMax] >>> */
				694
				695	int
				696	CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t td, const void sptr,
				697	asn_app_consume_bytes_f app_errlog, void app_key) {
				698	const INTEGER_t st = (const INTEGER_t )sptr;
				699	long value;
				700
				701	if(!sptr) {
				702	_ASN_ERRLOG(app_errlog, app_key,
				703	"%s: value not given (%s:%d)",
				704	td->name, __FILE__, __LINE__);
				705	return -1;
				706	}
				707
				708	if(asn_INTEGER2long(st, &value)) {
				709	_ASN_ERRLOG(app_errlog, app_key,
				710	"%s: value too large (%s:%d)",
				711	td->name, __FILE__, __LINE__);
				712	return -1;
				713	}
				714
				715	if((value >= 1)) {
				716	/* Constraint check succeeded */
				717	return 0;
				718	} else {
				719	_ASN_ERRLOG(app_errlog, app_key,
				720	"%s: constraint failed (%s:%d)",
				721	td->name, __FILE__, __LINE__);
				722	return -1;
				723	}
				724	}
				725
				726	/*
				727	* This type is implemented using INTEGER,
				728	* so here we adjust the DEF accordingly.
				729	*/
				730	static void
				731	CN_IntegerLowMax_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				732	td->free_struct = asn_DEF_INTEGER.free_struct;
				733	td->print_struct = asn_DEF_INTEGER.print_struct;
				734	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				735	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				736	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				737	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				738	td->elements = asn_DEF_INTEGER.elements;
				739	td->elements_count = asn_DEF_INTEGER.elements_count;
				740	td->specifics = asn_DEF_INTEGER.specifics;
				741	}
				742
				743	void
				744	CN_IntegerLowMax_free(asn_TYPE_descriptor_t *td,
				745	void *struct_ptr, int contents_only) {
				746	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				747	td->free_struct(td, struct_ptr, contents_only);
				748	}
				749
				750	int
				751	CN_IntegerLowMax_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				752	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				753	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				754	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				755	}
				756
				757	asn_dec_rval_t
				758	CN_IntegerLowMax_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				759	void *structure, const void bufptr, size_t size, int tag_mode) {
				760	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				761	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				762	}
				763
				764	asn_enc_rval_t
				765	CN_IntegerLowMax_encode_der(asn_TYPE_descriptor_t *td,
				766	void *structure, int tag_mode, ber_tlv_tag_t tag,
				767	asn_app_consume_bytes_f cb, void app_key) {
				768	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				769	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				770	}
				771
				772	asn_dec_rval_t
				773	CN_IntegerLowMax_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				774	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				775	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				776	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				777	}
				778
				779	asn_enc_rval_t
				780	CN_IntegerLowMax_encode_xer(asn_TYPE_descriptor_t td, void structure,
				781	int ilevel, enum xer_encoder_flags_e flags,
				782	asn_app_consume_bytes_f cb, void app_key) {
				783	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				784	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				785	}
				786
				787
				788	/* <<< STAT-DEFS [CN-IntegerLowMax] >>> */
				789
				790	static ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_1_tags[] = {
				791	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				792	};
				793	asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax = {
				794	"CN-IntegerLowMax",
				795	"CN-IntegerLowMax",
				796	CN_IntegerLowMax_free,
				797	CN_IntegerLowMax_print,
				798	CN_IntegerLowMax_constraint,
				799	CN_IntegerLowMax_decode_ber,
				800	CN_IntegerLowMax_encode_der,
				801	CN_IntegerLowMax_decode_xer,
				802	CN_IntegerLowMax_encode_xer,
				803	0, /* Use generic outmost tag fetcher */
				804	asn_DEF_CN_IntegerLowMax_1_tags,
				805	sizeof(asn_DEF_CN_IntegerLowMax_1_tags)
				806	/sizeof(asn_DEF_CN_IntegerLowMax_1_tags[0]), /* 1 */
				807	asn_DEF_CN_IntegerLowMax_1_tags, /* Same as above */
				808	sizeof(asn_DEF_CN_IntegerLowMax_1_tags)
				809	/sizeof(asn_DEF_CN_IntegerLowMax_1_tags[0]), /* 1 */
				810	0, 0, /* No members */
				811	0 /* No specifics */
				812	};
				813
				814
				815	/* <<< INCLUDES [NO-IntegerHighMax] >>> */
				816
				817	#include <INTEGER.h>
				818
				819	/* <<< TYPE-DECLS [NO-IntegerHighMax] >>> */
				820
				821	typedef INTEGER_t NO_IntegerHighMax_t;
				822
				823	/* <<< FUNC-DECLS [NO-IntegerHighMax] >>> */
				824
				825	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax;
				826	asn_struct_free_f NO_IntegerHighMax_free;
				827	asn_struct_print_f NO_IntegerHighMax_print;
				828	asn_constr_check_f NO_IntegerHighMax_constraint;
				829	ber_type_decoder_f NO_IntegerHighMax_decode_ber;
				830	der_type_encoder_f NO_IntegerHighMax_encode_der;
				831	xer_type_decoder_f NO_IntegerHighMax_decode_xer;
				832	xer_type_encoder_f NO_IntegerHighMax_encode_xer;
				833
				834	/* <<< CODE [NO-IntegerHighMax] >>> */
				835
				836	int
				837	NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t td, const void sptr,
				838	asn_app_consume_bytes_f app_errlog, void app_key) {
				839	const INTEGER_t st = (const INTEGER_t )sptr;
				840	long value;
				841
				842	if(!sptr) {
				843	_ASN_ERRLOG(app_errlog, app_key,
				844	"%s: value not given (%s:%d)",
				845	td->name, __FILE__, __LINE__);
				846	return -1;
				847	}
				848
				849	if(asn_INTEGER2long(st, &value)) {
				850	_ASN_ERRLOG(app_errlog, app_key,
				851	"%s: value too large (%s:%d)",
				852	td->name, __FILE__, __LINE__);
				853	return -1;
				854	}
				855
				856	if((value >= 5000000000)) {
				857	/* Constraint check succeeded */
				858	return 0;
				859	} else {
				860	_ASN_ERRLOG(app_errlog, app_key,
				861	"%s: constraint failed (%s:%d)",
				862	td->name, __FILE__, __LINE__);
				863	return -1;
				864	}
				865	}
				866
				867	/*
				868	* This type is implemented using INTEGER,
				869	* so here we adjust the DEF accordingly.
				870	*/
				871	static void
				872	NO_IntegerHighMax_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				873	td->free_struct = asn_DEF_INTEGER.free_struct;
				874	td->print_struct = asn_DEF_INTEGER.print_struct;
				875	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				876	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				877	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				878	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				879	td->elements = asn_DEF_INTEGER.elements;
				880	td->elements_count = asn_DEF_INTEGER.elements_count;
				881	td->specifics = asn_DEF_INTEGER.specifics;
				882	}
				883
				884	void
				885	NO_IntegerHighMax_free(asn_TYPE_descriptor_t *td,
				886	void *struct_ptr, int contents_only) {
				887	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				888	td->free_struct(td, struct_ptr, contents_only);
				889	}
				890
				891	int
				892	NO_IntegerHighMax_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				893	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				894	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				895	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				896	}
				897
				898	asn_dec_rval_t
				899	NO_IntegerHighMax_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				900	void *structure, const void bufptr, size_t size, int tag_mode) {
				901	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				902	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				903	}
				904
				905	asn_enc_rval_t
				906	NO_IntegerHighMax_encode_der(asn_TYPE_descriptor_t *td,
				907	void *structure, int tag_mode, ber_tlv_tag_t tag,
				908	asn_app_consume_bytes_f cb, void app_key) {
				909	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				910	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				911	}
				912
				913	asn_dec_rval_t
				914	NO_IntegerHighMax_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				915	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				916	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				917	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				918	}
				919
				920	asn_enc_rval_t
				921	NO_IntegerHighMax_encode_xer(asn_TYPE_descriptor_t td, void structure,
				922	int ilevel, enum xer_encoder_flags_e flags,
				923	asn_app_consume_bytes_f cb, void app_key) {
				924	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				925	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				926	}
				927
				928
				929	/* <<< STAT-DEFS [NO-IntegerHighMax] >>> */
				930
				931	static ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_1_tags[] = {
				932	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				933	};
				934	asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax = {
				935	"NO-IntegerHighMax",
				936	"NO-IntegerHighMax",
				937	NO_IntegerHighMax_free,
				938	NO_IntegerHighMax_print,
				939	NO_IntegerHighMax_constraint,
				940	NO_IntegerHighMax_decode_ber,
				941	NO_IntegerHighMax_encode_der,
				942	NO_IntegerHighMax_decode_xer,
				943	NO_IntegerHighMax_encode_xer,
				944	0, /* Use generic outmost tag fetcher */
				945	asn_DEF_NO_IntegerHighMax_1_tags,
				946	sizeof(asn_DEF_NO_IntegerHighMax_1_tags)
				947	/sizeof(asn_DEF_NO_IntegerHighMax_1_tags[0]), /* 1 */
				948	asn_DEF_NO_IntegerHighMax_1_tags, /* Same as above */
				949	sizeof(asn_DEF_NO_IntegerHighMax_1_tags)
				950	/sizeof(asn_DEF_NO_IntegerHighMax_1_tags[0]), /* 1 */
				951	0, 0, /* No members */
				952	0 /* No specifics */
				953	};
				954
				955
				956	/* <<< INCLUDES [NO-IntegerLowestMax] >>> */
				957
				958	#include <INTEGER.h>
				959
				960	/* <<< TYPE-DECLS [NO-IntegerLowestMax] >>> */
				961
				962	typedef INTEGER_t NO_IntegerLowestMax_t;
				963
				964	/* <<< FUNC-DECLS [NO-IntegerLowestMax] >>> */
				965
				966	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax;
				967	asn_struct_free_f NO_IntegerLowestMax_free;
				968	asn_struct_print_f NO_IntegerLowestMax_print;
				969	asn_constr_check_f NO_IntegerLowestMax_constraint;
				970	ber_type_decoder_f NO_IntegerLowestMax_decode_ber;
				971	der_type_encoder_f NO_IntegerLowestMax_encode_der;
				972	xer_type_decoder_f NO_IntegerLowestMax_decode_xer;
				973	xer_type_encoder_f NO_IntegerLowestMax_encode_xer;
				974
				975	/* <<< CODE [NO-IntegerLowestMax] >>> */
				976
				977	int
				978	NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t td, const void sptr,
				979	asn_app_consume_bytes_f app_errlog, void app_key) {
				980	const INTEGER_t st = (const INTEGER_t )sptr;
				981	long value;
				982
				983	if(!sptr) {
				984	_ASN_ERRLOG(app_errlog, app_key,
				985	"%s: value not given (%s:%d)",
				986	td->name, __FILE__, __LINE__);
				987	return -1;
				988	}
				989
				990	if(asn_INTEGER2long(st, &value)) {
				991	_ASN_ERRLOG(app_errlog, app_key,
				992	"%s: value too large (%s:%d)",
				993	td->name, __FILE__, __LINE__);
				994	return -1;
				995	}
				996
				997	if((value >= -5000000000)) {
				998	/* Constraint check succeeded */
				999	return 0;
				1000	} else {
				1001	_ASN_ERRLOG(app_errlog, app_key,
				1002	"%s: constraint failed (%s:%d)",
				1003	td->name, __FILE__, __LINE__);
				1004	return -1;
				1005	}
				1006	}
				1007
				1008	/*
				1009	* This type is implemented using INTEGER,
				1010	* so here we adjust the DEF accordingly.
				1011	*/
				1012	static void
				1013	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1014	td->free_struct = asn_DEF_INTEGER.free_struct;
				1015	td->print_struct = asn_DEF_INTEGER.print_struct;
				1016	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1017	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1018	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1019	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1020	td->elements = asn_DEF_INTEGER.elements;
				1021	td->elements_count = asn_DEF_INTEGER.elements_count;
				1022	td->specifics = asn_DEF_INTEGER.specifics;
				1023	}
				1024
				1025	void
				1026	NO_IntegerLowestMax_free(asn_TYPE_descriptor_t *td,
				1027	void *struct_ptr, int contents_only) {
				1028	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1029	td->free_struct(td, struct_ptr, contents_only);
				1030	}
				1031
				1032	int
				1033	NO_IntegerLowestMax_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1034	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1035	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1036	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1037	}
				1038
				1039	asn_dec_rval_t
				1040	NO_IntegerLowestMax_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1041	void *structure, const void bufptr, size_t size, int tag_mode) {
				1042	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1043	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1044	}
				1045
				1046	asn_enc_rval_t
				1047	NO_IntegerLowestMax_encode_der(asn_TYPE_descriptor_t *td,
				1048	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1049	asn_app_consume_bytes_f cb, void app_key) {
				1050	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1051	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1052	}
				1053
				1054	asn_dec_rval_t
				1055	NO_IntegerLowestMax_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1056	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1057	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1058	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1059	}
				1060
				1061	asn_enc_rval_t
				1062	NO_IntegerLowestMax_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1063	int ilevel, enum xer_encoder_flags_e flags,
				1064	asn_app_consume_bytes_f cb, void app_key) {
				1065	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1066	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1067	}
				1068
				1069
				1070	/* <<< STAT-DEFS [NO-IntegerLowestMax] >>> */
				1071
				1072	static ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_1_tags[] = {
				1073	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1074	};
				1075	asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
				1076	"NO-IntegerLowestMax",
				1077	"NO-IntegerLowestMax",
				1078	NO_IntegerLowestMax_free,
				1079	NO_IntegerLowestMax_print,
				1080	NO_IntegerLowestMax_constraint,
				1081	NO_IntegerLowestMax_decode_ber,
				1082	NO_IntegerLowestMax_encode_der,
				1083	NO_IntegerLowestMax_decode_xer,
				1084	NO_IntegerLowestMax_encode_xer,
				1085	0, /* Use generic outmost tag fetcher */
				1086	asn_DEF_NO_IntegerLowestMax_1_tags,
				1087	sizeof(asn_DEF_NO_IntegerLowestMax_1_tags)
				1088	/sizeof(asn_DEF_NO_IntegerLowestMax_1_tags[0]), /* 1 */
				1089	asn_DEF_NO_IntegerLowestMax_1_tags, /* Same as above */
				1090	sizeof(asn_DEF_NO_IntegerLowestMax_1_tags)
				1091	/sizeof(asn_DEF_NO_IntegerLowestMax_1_tags[0]), /* 1 */
				1092	0, 0, /* No members */
				1093	0 /* No specifics */
				1094	};
				1095
				1096
				1097	/* <<< INCLUDES [NO-IntegerOutRange] >>> */
				1098
				1099	#include <INTEGER.h>
				1100
				1101	/* <<< TYPE-DECLS [NO-IntegerOutRange] >>> */
				1102
				1103	typedef INTEGER_t NO_IntegerOutRange_t;
				1104
				1105	/* <<< FUNC-DECLS [NO-IntegerOutRange] >>> */
				1106
				1107	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange;
				1108	asn_struct_free_f NO_IntegerOutRange_free;
				1109	asn_struct_print_f NO_IntegerOutRange_print;
				1110	asn_constr_check_f NO_IntegerOutRange_constraint;
				1111	ber_type_decoder_f NO_IntegerOutRange_decode_ber;
				1112	der_type_encoder_f NO_IntegerOutRange_encode_der;
				1113	xer_type_decoder_f NO_IntegerOutRange_decode_xer;
				1114	xer_type_encoder_f NO_IntegerOutRange_encode_xer;
				1115
				1116	/* <<< CODE [NO-IntegerOutRange] >>> */
				1117
				1118	int
				1119	NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1120	asn_app_consume_bytes_f app_errlog, void app_key) {
				1121	const INTEGER_t st = (const INTEGER_t )sptr;
				1122	long value;
				1123
				1124	if(!sptr) {
				1125	_ASN_ERRLOG(app_errlog, app_key,
				1126	"%s: value not given (%s:%d)",
				1127	td->name, __FILE__, __LINE__);
				1128	return -1;
				1129	}
				1130
				1131	if(asn_INTEGER2long(st, &value)) {
				1132	_ASN_ERRLOG(app_errlog, app_key,
				1133	"%s: value too large (%s:%d)",
				1134	td->name, __FILE__, __LINE__);
				1135	return -1;
				1136	}
				1137
				1138	if((value >= 5000000000 && value <= 5000000001)) {
				1139	/* Constraint check succeeded */
				1140	return 0;
				1141	} else {
				1142	_ASN_ERRLOG(app_errlog, app_key,
				1143	"%s: constraint failed (%s:%d)",
				1144	td->name, __FILE__, __LINE__);
				1145	return -1;
				1146	}
				1147	}
				1148
				1149	/*
				1150	* This type is implemented using INTEGER,
				1151	* so here we adjust the DEF accordingly.
				1152	*/
				1153	static void
				1154	NO_IntegerOutRange_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1155	td->free_struct = asn_DEF_INTEGER.free_struct;
				1156	td->print_struct = asn_DEF_INTEGER.print_struct;
				1157	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1158	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1159	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1160	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1161	td->elements = asn_DEF_INTEGER.elements;
				1162	td->elements_count = asn_DEF_INTEGER.elements_count;
				1163	td->specifics = asn_DEF_INTEGER.specifics;
				1164	}
				1165
				1166	void
				1167	NO_IntegerOutRange_free(asn_TYPE_descriptor_t *td,
				1168	void *struct_ptr, int contents_only) {
				1169	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1170	td->free_struct(td, struct_ptr, contents_only);
				1171	}
				1172
				1173	int
				1174	NO_IntegerOutRange_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1175	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1176	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1177	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1178	}
				1179
				1180	asn_dec_rval_t
				1181	NO_IntegerOutRange_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1182	void *structure, const void bufptr, size_t size, int tag_mode) {
				1183	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1184	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1185	}
				1186
				1187	asn_enc_rval_t
				1188	NO_IntegerOutRange_encode_der(asn_TYPE_descriptor_t *td,
				1189	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1190	asn_app_consume_bytes_f cb, void app_key) {
				1191	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1192	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1193	}
				1194
				1195	asn_dec_rval_t
				1196	NO_IntegerOutRange_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1197	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1198	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1199	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1200	}
				1201
				1202	asn_enc_rval_t
				1203	NO_IntegerOutRange_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1204	int ilevel, enum xer_encoder_flags_e flags,
				1205	asn_app_consume_bytes_f cb, void app_key) {
				1206	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1207	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1208	}
				1209
				1210
				1211	/* <<< STAT-DEFS [NO-IntegerOutRange] >>> */
				1212
				1213	static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_1_tags[] = {
				1214	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1215	};
				1216	asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
				1217	"NO-IntegerOutRange",
				1218	"NO-IntegerOutRange",
				1219	NO_IntegerOutRange_free,
				1220	NO_IntegerOutRange_print,
				1221	NO_IntegerOutRange_constraint,
				1222	NO_IntegerOutRange_decode_ber,
				1223	NO_IntegerOutRange_encode_der,
				1224	NO_IntegerOutRange_decode_xer,
				1225	NO_IntegerOutRange_encode_xer,
				1226	0, /* Use generic outmost tag fetcher */
				1227	asn_DEF_NO_IntegerOutRange_1_tags,
				1228	sizeof(asn_DEF_NO_IntegerOutRange_1_tags)
				1229	/sizeof(asn_DEF_NO_IntegerOutRange_1_tags[0]), /* 1 */
				1230	asn_DEF_NO_IntegerOutRange_1_tags, /* Same as above */
				1231	sizeof(asn_DEF_NO_IntegerOutRange_1_tags)
				1232	/sizeof(asn_DEF_NO_IntegerOutRange_1_tags[0]), /* 1 */
				1233	0, 0, /* No members */
				1234	0 /* No specifics */
				1235	};
				1236
				1237
				1238	/* <<< INCLUDES [NO-IntegerOutValue] >>> */
				1239
				1240	#include <INTEGER.h>
				1241
				1242	/* <<< TYPE-DECLS [NO-IntegerOutValue] >>> */
				1243
				1244	typedef INTEGER_t NO_IntegerOutValue_t;
				1245
				1246	/* <<< FUNC-DECLS [NO-IntegerOutValue] >>> */
				1247
				1248	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue;
				1249	asn_struct_free_f NO_IntegerOutValue_free;
				1250	asn_struct_print_f NO_IntegerOutValue_print;
				1251	asn_constr_check_f NO_IntegerOutValue_constraint;
				1252	ber_type_decoder_f NO_IntegerOutValue_decode_ber;
				1253	der_type_encoder_f NO_IntegerOutValue_encode_der;
				1254	xer_type_decoder_f NO_IntegerOutValue_decode_xer;
				1255	xer_type_encoder_f NO_IntegerOutValue_encode_xer;
				1256
				1257	/* <<< CODE [NO-IntegerOutValue] >>> */
				1258
				1259	int
				1260	NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1261	asn_app_consume_bytes_f app_errlog, void app_key) {
				1262	const INTEGER_t st = (const INTEGER_t )sptr;
				1263	long value;
				1264
				1265	if(!sptr) {
				1266	_ASN_ERRLOG(app_errlog, app_key,
				1267	"%s: value not given (%s:%d)",
				1268	td->name, __FILE__, __LINE__);
				1269	return -1;
				1270	}
				1271
				1272	if(asn_INTEGER2long(st, &value)) {
				1273	_ASN_ERRLOG(app_errlog, app_key,
				1274	"%s: value too large (%s:%d)",
				1275	td->name, __FILE__, __LINE__);
				1276	return -1;
				1277	}
				1278
				1279	if((value == 5000000000)) {
				1280	/* Constraint check succeeded */
				1281	return 0;
				1282	} else {
				1283	_ASN_ERRLOG(app_errlog, app_key,
				1284	"%s: constraint failed (%s:%d)",
				1285	td->name, __FILE__, __LINE__);
				1286	return -1;
				1287	}
				1288	}
				1289
				1290	/*
				1291	* This type is implemented using INTEGER,
				1292	* so here we adjust the DEF accordingly.
				1293	*/
				1294	static void
				1295	NO_IntegerOutValue_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1296	td->free_struct = asn_DEF_INTEGER.free_struct;
				1297	td->print_struct = asn_DEF_INTEGER.print_struct;
				1298	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1299	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1300	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1301	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1302	td->elements = asn_DEF_INTEGER.elements;
				1303	td->elements_count = asn_DEF_INTEGER.elements_count;
				1304	td->specifics = asn_DEF_INTEGER.specifics;
				1305	}
				1306
				1307	void
				1308	NO_IntegerOutValue_free(asn_TYPE_descriptor_t *td,
				1309	void *struct_ptr, int contents_only) {
				1310	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1311	td->free_struct(td, struct_ptr, contents_only);
				1312	}
				1313
				1314	int
				1315	NO_IntegerOutValue_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1316	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1317	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1318	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1319	}
				1320
				1321	asn_dec_rval_t
				1322	NO_IntegerOutValue_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1323	void *structure, const void bufptr, size_t size, int tag_mode) {
				1324	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1325	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1326	}
				1327
				1328	asn_enc_rval_t
				1329	NO_IntegerOutValue_encode_der(asn_TYPE_descriptor_t *td,
				1330	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1331	asn_app_consume_bytes_f cb, void app_key) {
				1332	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1333	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1334	}
				1335
				1336	asn_dec_rval_t
				1337	NO_IntegerOutValue_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1338	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1339	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1340	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1341	}
				1342
				1343	asn_enc_rval_t
				1344	NO_IntegerOutValue_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1345	int ilevel, enum xer_encoder_flags_e flags,
				1346	asn_app_consume_bytes_f cb, void app_key) {
				1347	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1348	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1349	}
				1350
				1351
				1352	/* <<< STAT-DEFS [NO-IntegerOutValue] >>> */
				1353
				1354	static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_1_tags[] = {
				1355	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1356	};
				1357	asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
				1358	"NO-IntegerOutValue",
				1359	"NO-IntegerOutValue",
				1360	NO_IntegerOutValue_free,
				1361	NO_IntegerOutValue_print,
				1362	NO_IntegerOutValue_constraint,
				1363	NO_IntegerOutValue_decode_ber,
				1364	NO_IntegerOutValue_encode_der,
				1365	NO_IntegerOutValue_decode_xer,
				1366	NO_IntegerOutValue_encode_xer,
				1367	0, /* Use generic outmost tag fetcher */
				1368	asn_DEF_NO_IntegerOutValue_1_tags,
				1369	sizeof(asn_DEF_NO_IntegerOutValue_1_tags)
				1370	/sizeof(asn_DEF_NO_IntegerOutValue_1_tags[0]), /* 1 */
				1371	asn_DEF_NO_IntegerOutValue_1_tags, /* Same as above */
				1372	sizeof(asn_DEF_NO_IntegerOutValue_1_tags)
				1373	/sizeof(asn_DEF_NO_IntegerOutValue_1_tags[0]), /* 1 */
				1374	0, 0, /* No members */
				1375	0 /* No specifics */
				1376	};
				1377
				1378
				1379	/* <<< INCLUDES [OK-IntegerInRange1] >>> */
				1380
				1381	#include <INTEGER.h>
				1382
				1383	/* <<< TYPE-DECLS [OK-IntegerInRange1] >>> */
				1384
				1385	typedef INTEGER_t OK_IntegerInRange1_t;
				1386
				1387	/* <<< FUNC-DECLS [OK-IntegerInRange1] >>> */
				1388
				1389	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1;
				1390	asn_struct_free_f OK_IntegerInRange1_free;
				1391	asn_struct_print_f OK_IntegerInRange1_print;
				1392	asn_constr_check_f OK_IntegerInRange1_constraint;
				1393	ber_type_decoder_f OK_IntegerInRange1_decode_ber;
				1394	der_type_encoder_f OK_IntegerInRange1_encode_der;
				1395	xer_type_decoder_f OK_IntegerInRange1_decode_xer;
				1396	xer_type_encoder_f OK_IntegerInRange1_encode_xer;
				1397
				1398	/* <<< CODE [OK-IntegerInRange1] >>> */
				1399
				1400	int
				1401	OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1402	asn_app_consume_bytes_f app_errlog, void app_key) {
				1403	const INTEGER_t st = (const INTEGER_t )sptr;
				1404	long value;
				1405
				1406	if(!sptr) {
				1407	_ASN_ERRLOG(app_errlog, app_key,
				1408	"%s: value not given (%s:%d)",
				1409	td->name, __FILE__, __LINE__);
				1410	return -1;
				1411	}
				1412
				1413	if(asn_INTEGER2long(st, &value)) {
				1414	_ASN_ERRLOG(app_errlog, app_key,
				1415	"%s: value too large (%s:%d)",
				1416	td->name, __FILE__, __LINE__);
				1417	return -1;
				1418	}
				1419
				1420	if((value >= -100 && value <= 100)) {
				1421	/* Constraint check succeeded */
				1422	return 0;
				1423	} else {
				1424	_ASN_ERRLOG(app_errlog, app_key,
				1425	"%s: constraint failed (%s:%d)",
				1426	td->name, __FILE__, __LINE__);
				1427	return -1;
				1428	}
				1429	}
				1430
				1431	/*
				1432	* This type is implemented using INTEGER,
				1433	* so here we adjust the DEF accordingly.
				1434	*/
				1435	static void
				1436	OK_IntegerInRange1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1437	td->free_struct = asn_DEF_INTEGER.free_struct;
				1438	td->print_struct = asn_DEF_INTEGER.print_struct;
				1439	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1440	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1441	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1442	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1443	td->elements = asn_DEF_INTEGER.elements;
				1444	td->elements_count = asn_DEF_INTEGER.elements_count;
				1445	td->specifics = asn_DEF_INTEGER.specifics;
				1446	}
				1447
				1448	void
				1449	OK_IntegerInRange1_free(asn_TYPE_descriptor_t *td,
				1450	void *struct_ptr, int contents_only) {
				1451	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1452	td->free_struct(td, struct_ptr, contents_only);
				1453	}
				1454
				1455	int
				1456	OK_IntegerInRange1_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1457	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1458	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1459	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1460	}
				1461
				1462	asn_dec_rval_t
				1463	OK_IntegerInRange1_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1464	void *structure, const void bufptr, size_t size, int tag_mode) {
				1465	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1466	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1467	}
				1468
				1469	asn_enc_rval_t
				1470	OK_IntegerInRange1_encode_der(asn_TYPE_descriptor_t *td,
				1471	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1472	asn_app_consume_bytes_f cb, void app_key) {
				1473	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1474	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1475	}
				1476
				1477	asn_dec_rval_t
				1478	OK_IntegerInRange1_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1479	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1480	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1481	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1482	}
				1483
				1484	asn_enc_rval_t
				1485	OK_IntegerInRange1_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1486	int ilevel, enum xer_encoder_flags_e flags,
				1487	asn_app_consume_bytes_f cb, void app_key) {
				1488	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1489	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1490	}
				1491
				1492
				1493	/* <<< STAT-DEFS [OK-IntegerInRange1] >>> */
				1494
				1495	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_1_tags[] = {
				1496	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1497	};
				1498	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1 = {
				1499	"OK-IntegerInRange1",
				1500	"OK-IntegerInRange1",
				1501	OK_IntegerInRange1_free,
				1502	OK_IntegerInRange1_print,
				1503	OK_IntegerInRange1_constraint,
				1504	OK_IntegerInRange1_decode_ber,
				1505	OK_IntegerInRange1_encode_der,
				1506	OK_IntegerInRange1_decode_xer,
				1507	OK_IntegerInRange1_encode_xer,
				1508	0, /* Use generic outmost tag fetcher */
				1509	asn_DEF_OK_IntegerInRange1_1_tags,
				1510	sizeof(asn_DEF_OK_IntegerInRange1_1_tags)
				1511	/sizeof(asn_DEF_OK_IntegerInRange1_1_tags[0]), /* 1 */
				1512	asn_DEF_OK_IntegerInRange1_1_tags, /* Same as above */
				1513	sizeof(asn_DEF_OK_IntegerInRange1_1_tags)
				1514	/sizeof(asn_DEF_OK_IntegerInRange1_1_tags[0]), /* 1 */
				1515	0, 0, /* No members */
				1516	0 /* No specifics */
				1517	};
				1518
				1519
				1520	/* <<< INCLUDES [OK-IntegerInRange2] >>> */
				1521
				1522	#include <INTEGER.h>
				1523
				1524	/* <<< TYPE-DECLS [OK-IntegerInRange2] >>> */
				1525
				1526	typedef INTEGER_t OK_IntegerInRange2_t;
				1527
				1528	/* <<< FUNC-DECLS [OK-IntegerInRange2] >>> */
				1529
				1530	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2;
				1531	asn_struct_free_f OK_IntegerInRange2_free;
				1532	asn_struct_print_f OK_IntegerInRange2_print;
				1533	asn_constr_check_f OK_IntegerInRange2_constraint;
				1534	ber_type_decoder_f OK_IntegerInRange2_decode_ber;
				1535	der_type_encoder_f OK_IntegerInRange2_encode_der;
				1536	xer_type_decoder_f OK_IntegerInRange2_decode_xer;
				1537	xer_type_encoder_f OK_IntegerInRange2_encode_xer;
				1538
				1539	/* <<< CODE [OK-IntegerInRange2] >>> */
				1540
				1541	int
				1542	OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1543	asn_app_consume_bytes_f app_errlog, void app_key) {
				1544	const INTEGER_t st = (const INTEGER_t )sptr;
				1545	long value;
				1546
				1547	if(!sptr) {
				1548	_ASN_ERRLOG(app_errlog, app_key,
				1549	"%s: value not given (%s:%d)",
				1550	td->name, __FILE__, __LINE__);
				1551	return -1;
				1552	}
				1553
				1554	if(asn_INTEGER2long(st, &value)) {
				1555	_ASN_ERRLOG(app_errlog, app_key,
				1556	"%s: value too large (%s:%d)",
				1557	td->name, __FILE__, __LINE__);
				1558	return -1;
				1559	}
				1560
				1561	if(((value == -100) \|\| (value == 100))) {
				1562	/* Constraint check succeeded */
				1563	return 0;
				1564	} else {
				1565	_ASN_ERRLOG(app_errlog, app_key,
				1566	"%s: constraint failed (%s:%d)",
				1567	td->name, __FILE__, __LINE__);
				1568	return -1;
				1569	}
				1570	}
				1571
				1572	/*
				1573	* This type is implemented using INTEGER,
				1574	* so here we adjust the DEF accordingly.
				1575	*/
				1576	static void
				1577	OK_IntegerInRange2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1578	td->free_struct = asn_DEF_INTEGER.free_struct;
				1579	td->print_struct = asn_DEF_INTEGER.print_struct;
				1580	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1581	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1582	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1583	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1584	td->elements = asn_DEF_INTEGER.elements;
				1585	td->elements_count = asn_DEF_INTEGER.elements_count;
				1586	td->specifics = asn_DEF_INTEGER.specifics;
				1587	}
				1588
				1589	void
				1590	OK_IntegerInRange2_free(asn_TYPE_descriptor_t *td,
				1591	void *struct_ptr, int contents_only) {
				1592	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1593	td->free_struct(td, struct_ptr, contents_only);
				1594	}
				1595
				1596	int
				1597	OK_IntegerInRange2_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1598	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1599	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1600	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1601	}
				1602
				1603	asn_dec_rval_t
				1604	OK_IntegerInRange2_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1605	void *structure, const void bufptr, size_t size, int tag_mode) {
				1606	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1607	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1608	}
				1609
				1610	asn_enc_rval_t
				1611	OK_IntegerInRange2_encode_der(asn_TYPE_descriptor_t *td,
				1612	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1613	asn_app_consume_bytes_f cb, void app_key) {
				1614	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1615	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1616	}
				1617
				1618	asn_dec_rval_t
				1619	OK_IntegerInRange2_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1620	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1621	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1622	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1623	}
				1624
				1625	asn_enc_rval_t
				1626	OK_IntegerInRange2_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1627	int ilevel, enum xer_encoder_flags_e flags,
				1628	asn_app_consume_bytes_f cb, void app_key) {
				1629	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1630	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1631	}
				1632
				1633
				1634	/* <<< STAT-DEFS [OK-IntegerInRange2] >>> */
				1635
				1636	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_1_tags[] = {
				1637	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1638	};
				1639	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2 = {
				1640	"OK-IntegerInRange2",
				1641	"OK-IntegerInRange2",
				1642	OK_IntegerInRange2_free,
				1643	OK_IntegerInRange2_print,
				1644	OK_IntegerInRange2_constraint,
				1645	OK_IntegerInRange2_decode_ber,
				1646	OK_IntegerInRange2_encode_der,
				1647	OK_IntegerInRange2_decode_xer,
				1648	OK_IntegerInRange2_encode_xer,
				1649	0, /* Use generic outmost tag fetcher */
				1650	asn_DEF_OK_IntegerInRange2_1_tags,
				1651	sizeof(asn_DEF_OK_IntegerInRange2_1_tags)
				1652	/sizeof(asn_DEF_OK_IntegerInRange2_1_tags[0]), /* 1 */
				1653	asn_DEF_OK_IntegerInRange2_1_tags, /* Same as above */
				1654	sizeof(asn_DEF_OK_IntegerInRange2_1_tags)
				1655	/sizeof(asn_DEF_OK_IntegerInRange2_1_tags[0]), /* 1 */
				1656	0, 0, /* No members */
				1657	0 /* No specifics */
				1658	};
				1659
				1660
				1661	/* <<< INCLUDES [OK-IntegerInRange3] >>> */
				1662
				1663	#include <INTEGER.h>
				1664
				1665	/* <<< TYPE-DECLS [OK-IntegerInRange3] >>> */
				1666
				1667	typedef INTEGER_t OK_IntegerInRange3_t;
				1668
				1669	/* <<< FUNC-DECLS [OK-IntegerInRange3] >>> */
				1670
				1671	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3;
				1672	asn_struct_free_f OK_IntegerInRange3_free;
				1673	asn_struct_print_f OK_IntegerInRange3_print;
				1674	asn_constr_check_f OK_IntegerInRange3_constraint;
				1675	ber_type_decoder_f OK_IntegerInRange3_decode_ber;
				1676	der_type_encoder_f OK_IntegerInRange3_encode_der;
				1677	xer_type_decoder_f OK_IntegerInRange3_decode_xer;
				1678	xer_type_encoder_f OK_IntegerInRange3_encode_xer;
				1679
				1680	/* <<< CODE [OK-IntegerInRange3] >>> */
				1681
				1682	int
				1683	OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1684	asn_app_consume_bytes_f app_errlog, void app_key) {
				1685	const INTEGER_t st = (const INTEGER_t )sptr;
				1686	long value;
				1687
				1688	if(!sptr) {
				1689	_ASN_ERRLOG(app_errlog, app_key,
				1690	"%s: value not given (%s:%d)",
				1691	td->name, __FILE__, __LINE__);
				1692	return -1;
				1693	}
				1694
				1695	if(asn_INTEGER2long(st, &value)) {
				1696	_ASN_ERRLOG(app_errlog, app_key,
				1697	"%s: value too large (%s:%d)",
				1698	td->name, __FILE__, __LINE__);
				1699	return -1;
				1700	}
				1701
				1702	if((value >= -2147483648 && value <= 2147483647)) {
				1703	/* Constraint check succeeded */
				1704	return 0;
				1705	} else {
				1706	_ASN_ERRLOG(app_errlog, app_key,
				1707	"%s: constraint failed (%s:%d)",
				1708	td->name, __FILE__, __LINE__);
				1709	return -1;
				1710	}
				1711	}
				1712
				1713	/*
				1714	* This type is implemented using INTEGER,
				1715	* so here we adjust the DEF accordingly.
				1716	*/
				1717	static void
				1718	OK_IntegerInRange3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1719	td->free_struct = asn_DEF_INTEGER.free_struct;
				1720	td->print_struct = asn_DEF_INTEGER.print_struct;
				1721	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1722	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1723	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1724	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1725	td->elements = asn_DEF_INTEGER.elements;
				1726	td->elements_count = asn_DEF_INTEGER.elements_count;
				1727	td->specifics = asn_DEF_INTEGER.specifics;
				1728	}
				1729
				1730	void
				1731	OK_IntegerInRange3_free(asn_TYPE_descriptor_t *td,
				1732	void *struct_ptr, int contents_only) {
				1733	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1734	td->free_struct(td, struct_ptr, contents_only);
				1735	}
				1736
				1737	int
				1738	OK_IntegerInRange3_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1739	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1740	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1741	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1742	}
				1743
				1744	asn_dec_rval_t
				1745	OK_IntegerInRange3_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1746	void *structure, const void bufptr, size_t size, int tag_mode) {
				1747	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1748	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1749	}
				1750
				1751	asn_enc_rval_t
				1752	OK_IntegerInRange3_encode_der(asn_TYPE_descriptor_t *td,
				1753	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1754	asn_app_consume_bytes_f cb, void app_key) {
				1755	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1756	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1757	}
				1758
				1759	asn_dec_rval_t
				1760	OK_IntegerInRange3_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1761	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1762	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1763	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1764	}
				1765
				1766	asn_enc_rval_t
				1767	OK_IntegerInRange3_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1768	int ilevel, enum xer_encoder_flags_e flags,
				1769	asn_app_consume_bytes_f cb, void app_key) {
				1770	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1771	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1772	}
				1773
				1774
				1775	/* <<< STAT-DEFS [OK-IntegerInRange3] >>> */
				1776
				1777	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_1_tags[] = {
				1778	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1779	};
				1780	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3 = {
				1781	"OK-IntegerInRange3",
				1782	"OK-IntegerInRange3",
				1783	OK_IntegerInRange3_free,
				1784	OK_IntegerInRange3_print,
				1785	OK_IntegerInRange3_constraint,
				1786	OK_IntegerInRange3_decode_ber,
				1787	OK_IntegerInRange3_encode_der,
				1788	OK_IntegerInRange3_decode_xer,
				1789	OK_IntegerInRange3_encode_xer,
				1790	0, /* Use generic outmost tag fetcher */
				1791	asn_DEF_OK_IntegerInRange3_1_tags,
				1792	sizeof(asn_DEF_OK_IntegerInRange3_1_tags)
				1793	/sizeof(asn_DEF_OK_IntegerInRange3_1_tags[0]), /* 1 */
				1794	asn_DEF_OK_IntegerInRange3_1_tags, /* Same as above */
				1795	sizeof(asn_DEF_OK_IntegerInRange3_1_tags)
				1796	/sizeof(asn_DEF_OK_IntegerInRange3_1_tags[0]), /* 1 */
				1797	0, 0, /* No members */
				1798	0 /* No specifics */
				1799	};
				1800
				1801
				1802	/* <<< INCLUDES [OK-IntegerInRange4] >>> */
				1803
				1804	#include <INTEGER.h>
				1805
				1806	/* <<< TYPE-DECLS [OK-IntegerInRange4] >>> */
				1807
				1808	typedef INTEGER_t OK_IntegerInRange4_t;
				1809
				1810	/* <<< FUNC-DECLS [OK-IntegerInRange4] >>> */
				1811
				1812	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4;
				1813	asn_struct_free_f OK_IntegerInRange4_free;
				1814	asn_struct_print_f OK_IntegerInRange4_print;
				1815	asn_constr_check_f OK_IntegerInRange4_constraint;
				1816	ber_type_decoder_f OK_IntegerInRange4_decode_ber;
				1817	der_type_encoder_f OK_IntegerInRange4_encode_der;
				1818	xer_type_decoder_f OK_IntegerInRange4_decode_xer;
				1819	xer_type_encoder_f OK_IntegerInRange4_encode_xer;
				1820
				1821	/* <<< CODE [OK-IntegerInRange4] >>> */
				1822
				1823	int
				1824	OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1825	asn_app_consume_bytes_f app_errlog, void app_key) {
				1826	const INTEGER_t st = (const INTEGER_t )sptr;
				1827	long value;
				1828
				1829	if(!sptr) {
				1830	_ASN_ERRLOG(app_errlog, app_key,
				1831	"%s: value not given (%s:%d)",
				1832	td->name, __FILE__, __LINE__);
				1833	return -1;
				1834	}
				1835
				1836	if(asn_INTEGER2long(st, &value)) {
				1837	_ASN_ERRLOG(app_errlog, app_key,
				1838	"%s: value too large (%s:%d)",
				1839	td->name, __FILE__, __LINE__);
				1840	return -1;
				1841	}
				1842
				1843	if(((value == -2147483648) \|\| (value == 2147483647))) {
				1844	/* Constraint check succeeded */
				1845	return 0;
				1846	} else {
				1847	_ASN_ERRLOG(app_errlog, app_key,
				1848	"%s: constraint failed (%s:%d)",
				1849	td->name, __FILE__, __LINE__);
				1850	return -1;
				1851	}
				1852	}
				1853
				1854	/*
				1855	* This type is implemented using INTEGER,
				1856	* so here we adjust the DEF accordingly.
				1857	*/
				1858	static void
				1859	OK_IntegerInRange4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1860	td->free_struct = asn_DEF_INTEGER.free_struct;
				1861	td->print_struct = asn_DEF_INTEGER.print_struct;
				1862	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1863	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1864	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1865	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1866	td->elements = asn_DEF_INTEGER.elements;
				1867	td->elements_count = asn_DEF_INTEGER.elements_count;
				1868	td->specifics = asn_DEF_INTEGER.specifics;
				1869	}
				1870
				1871	void
				1872	OK_IntegerInRange4_free(asn_TYPE_descriptor_t *td,
				1873	void *struct_ptr, int contents_only) {
				1874	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1875	td->free_struct(td, struct_ptr, contents_only);
				1876	}
				1877
				1878	int
				1879	OK_IntegerInRange4_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1880	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1881	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1882	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1883	}
				1884
				1885	asn_dec_rval_t
				1886	OK_IntegerInRange4_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1887	void *structure, const void bufptr, size_t size, int tag_mode) {
				1888	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1889	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1890	}
				1891
				1892	asn_enc_rval_t
				1893	OK_IntegerInRange4_encode_der(asn_TYPE_descriptor_t *td,
				1894	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1895	asn_app_consume_bytes_f cb, void app_key) {
				1896	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1897	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1898	}
				1899
				1900	asn_dec_rval_t
				1901	OK_IntegerInRange4_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1902	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1903	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1904	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1905	}
				1906
				1907	asn_enc_rval_t
				1908	OK_IntegerInRange4_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1909	int ilevel, enum xer_encoder_flags_e flags,
				1910	asn_app_consume_bytes_f cb, void app_key) {
				1911	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1912	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1913	}
				1914
				1915
				1916	/* <<< STAT-DEFS [OK-IntegerInRange4] >>> */
				1917
				1918	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_1_tags[] = {
				1919	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1920	};
				1921	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4 = {
				1922	"OK-IntegerInRange4",
				1923	"OK-IntegerInRange4",
				1924	OK_IntegerInRange4_free,
				1925	OK_IntegerInRange4_print,
				1926	OK_IntegerInRange4_constraint,
				1927	OK_IntegerInRange4_decode_ber,
				1928	OK_IntegerInRange4_encode_der,
				1929	OK_IntegerInRange4_decode_xer,
				1930	OK_IntegerInRange4_encode_xer,
				1931	0, /* Use generic outmost tag fetcher */
				1932	asn_DEF_OK_IntegerInRange4_1_tags,
				1933	sizeof(asn_DEF_OK_IntegerInRange4_1_tags)
				1934	/sizeof(asn_DEF_OK_IntegerInRange4_1_tags[0]), /* 1 */
				1935	asn_DEF_OK_IntegerInRange4_1_tags, /* Same as above */
				1936	sizeof(asn_DEF_OK_IntegerInRange4_1_tags)
				1937	/sizeof(asn_DEF_OK_IntegerInRange4_1_tags[0]), /* 1 */
				1938	0, 0, /* No members */
				1939	0 /* No specifics */
				1940	};
				1941
				1942
				1943	/* <<< INCLUDES [OK-IntegerInRange5] >>> */
				1944
				1945	#include <INTEGER.h>
				1946
				1947	/* <<< TYPE-DECLS [OK-IntegerInRange5] >>> */
				1948
				1949	typedef INTEGER_t OK_IntegerInRange5_t;
				1950
				1951	/* <<< FUNC-DECLS [OK-IntegerInRange5] >>> */
				1952
				1953	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5;
				1954	asn_struct_free_f OK_IntegerInRange5_free;
				1955	asn_struct_print_f OK_IntegerInRange5_print;
				1956	asn_constr_check_f OK_IntegerInRange5_constraint;
				1957	ber_type_decoder_f OK_IntegerInRange5_decode_ber;
				1958	der_type_encoder_f OK_IntegerInRange5_encode_der;
				1959	xer_type_decoder_f OK_IntegerInRange5_decode_xer;
				1960	xer_type_encoder_f OK_IntegerInRange5_encode_xer;
				1961
				1962	/* <<< CODE [OK-IntegerInRange5] >>> */
				1963
				1964	int
				1965	OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1966	asn_app_consume_bytes_f app_errlog, void app_key) {
				1967	const INTEGER_t st = (const INTEGER_t )sptr;
				1968	long value;
				1969
				1970	if(!sptr) {
				1971	_ASN_ERRLOG(app_errlog, app_key,
				1972	"%s: value not given (%s:%d)",
				1973	td->name, __FILE__, __LINE__);
				1974	return -1;
				1975	}
				1976
				1977	if(asn_INTEGER2long(st, &value)) {
				1978	_ASN_ERRLOG(app_errlog, app_key,
				1979	"%s: value too large (%s:%d)",
				1980	td->name, __FILE__, __LINE__);
				1981	return -1;
				1982	}
				1983
				1984	if(((value == -2147483648) \|\| (value == 2147483647))) {
				1985	/* Constraint check succeeded */
				1986	return 0;
				1987	} else {
				1988	_ASN_ERRLOG(app_errlog, app_key,
				1989	"%s: constraint failed (%s:%d)",
				1990	td->name, __FILE__, __LINE__);
				1991	return -1;
				1992	}
				1993	}
				1994
				1995	/*
				1996	* This type is implemented using INTEGER,
				1997	* so here we adjust the DEF accordingly.
				1998	*/
				1999	static void
				2000	OK_IntegerInRange5_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				2001	td->free_struct = asn_DEF_INTEGER.free_struct;
				2002	td->print_struct = asn_DEF_INTEGER.print_struct;
				2003	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				2004	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				2005	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				2006	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				2007	td->elements = asn_DEF_INTEGER.elements;
				2008	td->elements_count = asn_DEF_INTEGER.elements_count;
				2009	td->specifics = asn_DEF_INTEGER.specifics;
				2010	}
				2011
				2012	void
				2013	OK_IntegerInRange5_free(asn_TYPE_descriptor_t *td,
				2014	void *struct_ptr, int contents_only) {
				2015	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				2016	td->free_struct(td, struct_ptr, contents_only);
				2017	}
				2018
				2019	int
				2020	OK_IntegerInRange5_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				2021	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				2022	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				2023	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				2024	}
				2025
				2026	asn_dec_rval_t
				2027	OK_IntegerInRange5_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2028	void *structure, const void bufptr, size_t size, int tag_mode) {
				2029	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				2030	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				2031	}
				2032
				2033	asn_enc_rval_t
				2034	OK_IntegerInRange5_encode_der(asn_TYPE_descriptor_t *td,
				2035	void *structure, int tag_mode, ber_tlv_tag_t tag,
				2036	asn_app_consume_bytes_f cb, void app_key) {
				2037	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				2038	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				2039	}
				2040
				2041	asn_dec_rval_t
				2042	OK_IntegerInRange5_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2043	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				2044	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				2045	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				2046	}
				2047
				2048	asn_enc_rval_t
				2049	OK_IntegerInRange5_encode_xer(asn_TYPE_descriptor_t td, void structure,
				2050	int ilevel, enum xer_encoder_flags_e flags,
				2051	asn_app_consume_bytes_f cb, void app_key) {
				2052	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				2053	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				2054	}
				2055
				2056
				2057	/* <<< STAT-DEFS [OK-IntegerInRange5] >>> */
				2058
				2059	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_1_tags[] = {
				2060	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				2061	};
				2062	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
				2063	"OK-IntegerInRange5",
				2064	"OK-IntegerInRange5",
				2065	OK_IntegerInRange5_free,
				2066	OK_IntegerInRange5_print,
				2067	OK_IntegerInRange5_constraint,
				2068	OK_IntegerInRange5_decode_ber,
				2069	OK_IntegerInRange5_encode_der,
				2070	OK_IntegerInRange5_decode_xer,
				2071	OK_IntegerInRange5_encode_xer,
				2072	0, /* Use generic outmost tag fetcher */
				2073	asn_DEF_OK_IntegerInRange5_1_tags,
				2074	sizeof(asn_DEF_OK_IntegerInRange5_1_tags)
				2075	/sizeof(asn_DEF_OK_IntegerInRange5_1_tags[0]), /* 1 */
				2076	asn_DEF_OK_IntegerInRange5_1_tags, /* Same as above */
				2077	sizeof(asn_DEF_OK_IntegerInRange5_1_tags)
				2078	/sizeof(asn_DEF_OK_IntegerInRange5_1_tags[0]), /* 1 */
				2079	0, 0, /* No members */
				2080	0 /* No specifics */
				2081	};
				2082