tests/tests-asn1c-compiler/154-with-REAL-components-OK.asn1.-Pfwide-types

/*** <<< INCLUDES [UnconstrainedREAL] >>> ***/

#include <REAL.h>

/*** <<< TYPE-DECLS [UnconstrainedREAL] >>> ***/

typedef REAL_t	 UnconstrainedREAL_t;

/*** <<< FUNC-DECLS [UnconstrainedREAL] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_UnconstrainedREAL;
asn_struct_free_f UnconstrainedREAL_free;
asn_struct_print_f UnconstrainedREAL_print;
asn_constr_check_f UnconstrainedREAL_constraint;
ber_type_decoder_f UnconstrainedREAL_decode_ber;
der_type_encoder_f UnconstrainedREAL_encode_der;
xer_type_decoder_f UnconstrainedREAL_decode_xer;
xer_type_encoder_f UnconstrainedREAL_encode_xer;

/*** <<< CODE [UnconstrainedREAL] >>> ***/

/*
 * This type is implemented using REAL,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [UnconstrainedREAL] >>> ***/

static const ber_tlv_tag_t asn_DEF_UnconstrainedREAL_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_UnconstrainedREAL = {
	"UnconstrainedREAL",
	"UnconstrainedREAL",
	&asn_OP_REAL,
	asn_DEF_UnconstrainedREAL_tags_1,
	sizeof(asn_DEF_UnconstrainedREAL_tags_1)
		/sizeof(asn_DEF_UnconstrainedREAL_tags_1[0]), /* 1 */
	asn_DEF_UnconstrainedREAL_tags_1,	/* Same as above */
	sizeof(asn_DEF_UnconstrainedREAL_tags_1)
		/sizeof(asn_DEF_UnconstrainedREAL_tags_1[0]), /* 1 */
	{ 0, 0, REAL_constraint },
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [WeirdlyConstrainedREAL] >>> ***/

#include <REAL.h>

/*** <<< TYPE-DECLS [WeirdlyConstrainedREAL] >>> ***/

typedef REAL_t	 WeirdlyConstrainedREAL_t;

/*** <<< FUNC-DECLS [WeirdlyConstrainedREAL] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_WeirdlyConstrainedREAL;
asn_struct_free_f WeirdlyConstrainedREAL_free;
asn_struct_print_f WeirdlyConstrainedREAL_print;
asn_constr_check_f WeirdlyConstrainedREAL_constraint;
ber_type_decoder_f WeirdlyConstrainedREAL_decode_ber;
der_type_encoder_f WeirdlyConstrainedREAL_encode_der;
xer_type_decoder_f WeirdlyConstrainedREAL_decode_xer;
xer_type_encoder_f WeirdlyConstrainedREAL_encode_xer;

/*** <<< CODE [WeirdlyConstrainedREAL] >>> ***/

int
WeirdlyConstrainedREAL_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	const REAL_t *st = (const REAL_t *)sptr;
	double value;
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	if(asn_REAL2double(st, &value)) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value too large (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	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 REAL,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [WeirdlyConstrainedREAL] >>> ***/

static const ber_tlv_tag_t asn_DEF_WeirdlyConstrainedREAL_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_WeirdlyConstrainedREAL = {
	"WeirdlyConstrainedREAL",
	"WeirdlyConstrainedREAL",
	&asn_OP_REAL,
	asn_DEF_WeirdlyConstrainedREAL_tags_1,
	sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1)
		/sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1[0]), /* 1 */
	asn_DEF_WeirdlyConstrainedREAL_tags_1,	/* Same as above */
	sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1)
		/sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1[0]), /* 1 */
	{ 0, 0, WeirdlyConstrainedREAL_constraint },
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [Indirect-IEEE-binary32] >>> ***/

#include "UnconstrainedREAL.h"

/*** <<< TYPE-DECLS [Indirect-IEEE-binary32] >>> ***/

typedef UnconstrainedREAL_t	 Indirect_IEEE_binary32_t;

/*** <<< FUNC-DECLS [Indirect-IEEE-binary32] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_Indirect_IEEE_binary32;
extern const asn_REAL_specifics_t asn_SPC_Indirect_IEEE_binary32_specs_1;
asn_struct_free_f Indirect_IEEE_binary32_free;
asn_struct_print_f Indirect_IEEE_binary32_print;
asn_constr_check_f Indirect_IEEE_binary32_constraint;
ber_type_decoder_f Indirect_IEEE_binary32_decode_ber;
der_type_encoder_f Indirect_IEEE_binary32_encode_der;
xer_type_decoder_f Indirect_IEEE_binary32_decode_xer;
xer_type_encoder_f Indirect_IEEE_binary32_encode_xer;

/*** <<< CODE [Indirect-IEEE-binary32] >>> ***/

int
Indirect_IEEE_binary32_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using UnconstrainedREAL,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [Indirect-IEEE-binary32] >>> ***/

const asn_NativeReal_specifics_t asn_SPC_Indirect_IEEE_binary32_specs_1 = {
	4	/* Use 'float' type. */
};
static const ber_tlv_tag_t asn_DEF_Indirect_IEEE_binary32_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_Indirect_IEEE_binary32 = {
	"Indirect-IEEE-binary32",
	"Indirect-IEEE-binary32",
	&asn_OP_REAL,
	asn_DEF_Indirect_IEEE_binary32_tags_1,
	sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1)
		/sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1[0]), /* 1 */
	asn_DEF_Indirect_IEEE_binary32_tags_1,	/* Same as above */
	sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1)
		/sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1[0]), /* 1 */
	{ 0, 0, Indirect_IEEE_binary32_constraint },
	0, 0,	/* No members */
	&asn_SPC_Indirect_IEEE_binary32_specs_1	/* Additional specs */
};


/*** <<< INCLUDES [IEEE-binary32-w] >>> ***/

#include <NativeReal.h>

/*** <<< TYPE-DECLS [IEEE-binary32-w] >>> ***/

typedef float	 IEEE_binary32_w_t;

/*** <<< FUNC-DECLS [IEEE-binary32-w] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w;
extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w_specs_1;
asn_struct_free_f IEEE_binary32_w_free;
asn_struct_print_f IEEE_binary32_w_print;
asn_constr_check_f IEEE_binary32_w_constraint;
ber_type_decoder_f IEEE_binary32_w_decode_ber;
der_type_encoder_f IEEE_binary32_w_encode_der;
xer_type_decoder_f IEEE_binary32_w_decode_xer;
xer_type_encoder_f IEEE_binary32_w_encode_xer;

/*** <<< CODE [IEEE-binary32-w] >>> ***/

int
IEEE_binary32_w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using NativeReal,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [IEEE-binary32-w] >>> ***/

const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w_specs_1 = {
	4	/* Use 'float' type. */
};
static const ber_tlv_tag_t asn_DEF_IEEE_binary32_w_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w = {
	"IEEE-binary32-w",
	"IEEE-binary32-w",
	&asn_OP_NativeReal,
	asn_DEF_IEEE_binary32_w_tags_1,
	sizeof(asn_DEF_IEEE_binary32_w_tags_1)
		/sizeof(asn_DEF_IEEE_binary32_w_tags_1[0]), /* 1 */
	asn_DEF_IEEE_binary32_w_tags_1,	/* Same as above */
	sizeof(asn_DEF_IEEE_binary32_w_tags_1)
		/sizeof(asn_DEF_IEEE_binary32_w_tags_1[0]), /* 1 */
	{ 0, 0, IEEE_binary32_w_constraint },
	0, 0,	/* No members */
	&asn_SPC_IEEE_binary32_w_specs_1	/* Additional specs */
};


/*** <<< INCLUDES [IEEE-binary32-0w] >>> ***/

#include <NativeReal.h>

/*** <<< TYPE-DECLS [IEEE-binary32-0w] >>> ***/

typedef float	 IEEE_binary32_0w_t;

/*** <<< FUNC-DECLS [IEEE-binary32-0w] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_0w;
extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_0w_specs_1;
asn_struct_free_f IEEE_binary32_0w_free;
asn_struct_print_f IEEE_binary32_0w_print;
asn_constr_check_f IEEE_binary32_0w_constraint;
ber_type_decoder_f IEEE_binary32_0w_decode_ber;
der_type_encoder_f IEEE_binary32_0w_encode_der;
xer_type_decoder_f IEEE_binary32_0w_decode_xer;
xer_type_encoder_f IEEE_binary32_0w_encode_xer;

/*** <<< CODE [IEEE-binary32-0w] >>> ***/

int
IEEE_binary32_0w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using NativeReal,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [IEEE-binary32-0w] >>> ***/

const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_0w_specs_1 = {
	4	/* Use 'float' type. */
};
static const ber_tlv_tag_t asn_DEF_IEEE_binary32_0w_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_0w = {
	"IEEE-binary32-0w",
	"IEEE-binary32-0w",
	&asn_OP_NativeReal,
	asn_DEF_IEEE_binary32_0w_tags_1,
	sizeof(asn_DEF_IEEE_binary32_0w_tags_1)
		/sizeof(asn_DEF_IEEE_binary32_0w_tags_1[0]), /* 1 */
	asn_DEF_IEEE_binary32_0w_tags_1,	/* Same as above */
	sizeof(asn_DEF_IEEE_binary32_0w_tags_1)
		/sizeof(asn_DEF_IEEE_binary32_0w_tags_1[0]), /* 1 */
	{ 0, 0, IEEE_binary32_0w_constraint },
	0, 0,	/* No members */
	&asn_SPC_IEEE_binary32_0w_specs_1	/* Additional specs */
};


/*** <<< INCLUDES [IEEE-binary32-w0] >>> ***/

#include <NativeReal.h>

/*** <<< TYPE-DECLS [IEEE-binary32-w0] >>> ***/

typedef float	 IEEE_binary32_w0_t;

/*** <<< FUNC-DECLS [IEEE-binary32-w0] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w0;
extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w0_specs_1;
asn_struct_free_f IEEE_binary32_w0_free;
asn_struct_print_f IEEE_binary32_w0_print;
asn_constr_check_f IEEE_binary32_w0_constraint;
ber_type_decoder_f IEEE_binary32_w0_decode_ber;
der_type_encoder_f IEEE_binary32_w0_encode_der;
xer_type_decoder_f IEEE_binary32_w0_decode_xer;
xer_type_encoder_f IEEE_binary32_w0_encode_xer;

/*** <<< CODE [IEEE-binary32-w0] >>> ***/

int
IEEE_binary32_w0_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using NativeReal,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [IEEE-binary32-w0] >>> ***/

const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w0_specs_1 = {
	4	/* Use 'float' type. */
};
static const ber_tlv_tag_t asn_DEF_IEEE_binary32_w0_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w0 = {
	"IEEE-binary32-w0",
	"IEEE-binary32-w0",
	&asn_OP_NativeReal,
	asn_DEF_IEEE_binary32_w0_tags_1,
	sizeof(asn_DEF_IEEE_binary32_w0_tags_1)
		/sizeof(asn_DEF_IEEE_binary32_w0_tags_1[0]), /* 1 */
	asn_DEF_IEEE_binary32_w0_tags_1,	/* Same as above */
	sizeof(asn_DEF_IEEE_binary32_w0_tags_1)
		/sizeof(asn_DEF_IEEE_binary32_w0_tags_1[0]), /* 1 */
	{ 0, 0, IEEE_binary32_w0_constraint },
	0, 0,	/* No members */
	&asn_SPC_IEEE_binary32_w0_specs_1	/* Additional specs */
};


/*** <<< INCLUDES [IEEE-binary64-w] >>> ***/

#include <NativeReal.h>

/*** <<< TYPE-DECLS [IEEE-binary64-w] >>> ***/

typedef double	 IEEE_binary64_w_t;

/*** <<< FUNC-DECLS [IEEE-binary64-w] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w;
asn_struct_free_f IEEE_binary64_w_free;
asn_struct_print_f IEEE_binary64_w_print;
asn_constr_check_f IEEE_binary64_w_constraint;
ber_type_decoder_f IEEE_binary64_w_decode_ber;
der_type_encoder_f IEEE_binary64_w_encode_der;
xer_type_decoder_f IEEE_binary64_w_decode_xer;
xer_type_encoder_f IEEE_binary64_w_encode_xer;

/*** <<< CODE [IEEE-binary64-w] >>> ***/

int
IEEE_binary64_w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using NativeReal,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [IEEE-binary64-w] >>> ***/

static const ber_tlv_tag_t asn_DEF_IEEE_binary64_w_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w = {
	"IEEE-binary64-w",
	"IEEE-binary64-w",
	&asn_OP_NativeReal,
	asn_DEF_IEEE_binary64_w_tags_1,
	sizeof(asn_DEF_IEEE_binary64_w_tags_1)
		/sizeof(asn_DEF_IEEE_binary64_w_tags_1[0]), /* 1 */
	asn_DEF_IEEE_binary64_w_tags_1,	/* Same as above */
	sizeof(asn_DEF_IEEE_binary64_w_tags_1)
		/sizeof(asn_DEF_IEEE_binary64_w_tags_1[0]), /* 1 */
	{ 0, 0, IEEE_binary64_w_constraint },
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [IEEE-binary64-0w] >>> ***/

#include <NativeReal.h>

/*** <<< TYPE-DECLS [IEEE-binary64-0w] >>> ***/

typedef double	 IEEE_binary64_0w_t;

/*** <<< FUNC-DECLS [IEEE-binary64-0w] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_0w;
asn_struct_free_f IEEE_binary64_0w_free;
asn_struct_print_f IEEE_binary64_0w_print;
asn_constr_check_f IEEE_binary64_0w_constraint;
ber_type_decoder_f IEEE_binary64_0w_decode_ber;
der_type_encoder_f IEEE_binary64_0w_encode_der;
xer_type_decoder_f IEEE_binary64_0w_decode_xer;
xer_type_encoder_f IEEE_binary64_0w_encode_xer;

/*** <<< CODE [IEEE-binary64-0w] >>> ***/

int
IEEE_binary64_0w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using NativeReal,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [IEEE-binary64-0w] >>> ***/

static const ber_tlv_tag_t asn_DEF_IEEE_binary64_0w_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_0w = {
	"IEEE-binary64-0w",
	"IEEE-binary64-0w",
	&asn_OP_NativeReal,
	asn_DEF_IEEE_binary64_0w_tags_1,
	sizeof(asn_DEF_IEEE_binary64_0w_tags_1)
		/sizeof(asn_DEF_IEEE_binary64_0w_tags_1[0]), /* 1 */
	asn_DEF_IEEE_binary64_0w_tags_1,	/* Same as above */
	sizeof(asn_DEF_IEEE_binary64_0w_tags_1)
		/sizeof(asn_DEF_IEEE_binary64_0w_tags_1[0]), /* 1 */
	{ 0, 0, IEEE_binary64_0w_constraint },
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [IEEE-binary64-w0] >>> ***/

#include <NativeReal.h>

/*** <<< TYPE-DECLS [IEEE-binary64-w0] >>> ***/

typedef double	 IEEE_binary64_w0_t;

/*** <<< FUNC-DECLS [IEEE-binary64-w0] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w0;
asn_struct_free_f IEEE_binary64_w0_free;
asn_struct_print_f IEEE_binary64_w0_print;
asn_constr_check_f IEEE_binary64_w0_constraint;
ber_type_decoder_f IEEE_binary64_w0_decode_ber;
der_type_encoder_f IEEE_binary64_w0_encode_der;
xer_type_decoder_f IEEE_binary64_w0_decode_xer;
xer_type_encoder_f IEEE_binary64_w0_encode_xer;

/*** <<< CODE [IEEE-binary64-w0] >>> ***/

int
IEEE_binary64_w0_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using NativeReal,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [IEEE-binary64-w0] >>> ***/

static const ber_tlv_tag_t asn_DEF_IEEE_binary64_w0_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w0 = {
	"IEEE-binary64-w0",
	"IEEE-binary64-w0",
	&asn_OP_NativeReal,
	asn_DEF_IEEE_binary64_w0_tags_1,
	sizeof(asn_DEF_IEEE_binary64_w0_tags_1)
		/sizeof(asn_DEF_IEEE_binary64_w0_tags_1[0]), /* 1 */
	asn_DEF_IEEE_binary64_w0_tags_1,	/* Same as above */
	sizeof(asn_DEF_IEEE_binary64_w0_tags_1)
		/sizeof(asn_DEF_IEEE_binary64_w0_tags_1[0]), /* 1 */
	{ 0, 0, IEEE_binary64_w0_constraint },
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [Test] >>> ***/

#include "Indirect-IEEE-binary32.h"
#include "IEEE-binary32-w.h"
#include "IEEE-binary32-0w.h"
#include "IEEE-binary32-w0.h"
#include "IEEE-binary64-w.h"
#include "IEEE-binary64-0w.h"
#include "IEEE-binary64-w0.h"
#include <constr_SEQUENCE.h>

/*** <<< TYPE-DECLS [Test] >>> ***/

typedef struct Test {
	Indirect_IEEE_binary32_t	 indirect_ieee_binary32;
	IEEE_binary32_w_t	 ieee_binary32_w;
	IEEE_binary32_0w_t	 ieee_binary32_0w;
	IEEE_binary32_w0_t	 ieee_binary32_w0;
	IEEE_binary64_w_t	 ieee_binary64_w;
	IEEE_binary64_0w_t	 ieee_binary64_0w;
	IEEE_binary64_w0_t	 ieee_binary64_w0;
	
	/* Context for parsing across buffer boundaries */
	asn_struct_ctx_t _asn_ctx;
} Test_t;

/*** <<< FUNC-DECLS [Test] >>> ***/

/* extern asn_TYPE_descriptor_t asn_DEF_indirect_ieee_binary32_2;	// (Use -fall-defs-global to expose) */
/* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w_3;	// (Use -fall-defs-global to expose) */
/* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_0w_4;	// (Use -fall-defs-global to expose) */
/* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w0_5;	// (Use -fall-defs-global to expose) */
extern asn_TYPE_descriptor_t asn_DEF_Test;

/*** <<< CODE [Test] >>> ***/

static int
indirect_ieee_binary32_2_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using Indirect_IEEE_binary32,
 * so here we adjust the DEF accordingly.
 */
static int
ieee_binary32_w_3_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using IEEE_binary32_w,
 * so here we adjust the DEF accordingly.
 */
static int
ieee_binary32_0w_4_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using IEEE_binary32_0w,
 * so here we adjust the DEF accordingly.
 */
static int
ieee_binary32_w0_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
	
	if(!sptr) {
		ASN__CTFAIL(app_key, td, sptr,
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
}

/*
 * This type is implemented using IEEE_binary32_w0,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [Test] >>> ***/

static const asn_NativeReal_specifics_t asn_SPC_indirect_ieee_binary32_specs_2 = {
	4	/* Use 'float' type. */
};
static const ber_tlv_tag_t asn_DEF_indirect_ieee_binary32_tags_2[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_indirect_ieee_binary32_2 = {
	"indirect-ieee-binary32",
	"indirect-ieee-binary32",
	&asn_OP_REAL,
	asn_DEF_indirect_ieee_binary32_tags_2,
	sizeof(asn_DEF_indirect_ieee_binary32_tags_2)
		/sizeof(asn_DEF_indirect_ieee_binary32_tags_2[0]), /* 1 */
	asn_DEF_indirect_ieee_binary32_tags_2,	/* Same as above */
	sizeof(asn_DEF_indirect_ieee_binary32_tags_2)
		/sizeof(asn_DEF_indirect_ieee_binary32_tags_2[0]), /* 1 */
	{ 0, 0, indirect_ieee_binary32_2_constraint },
	0, 0,	/* No members */
	&asn_SPC_indirect_ieee_binary32_specs_2	/* Additional specs */
};

static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_w_specs_3 = {
	4	/* Use 'float' type. */
};
static const ber_tlv_tag_t asn_DEF_ieee_binary32_w_tags_3[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w_3 = {
	"ieee-binary32-w",
	"ieee-binary32-w",
	&asn_OP_NativeReal,
	asn_DEF_ieee_binary32_w_tags_3,
	sizeof(asn_DEF_ieee_binary32_w_tags_3)
		/sizeof(asn_DEF_ieee_binary32_w_tags_3[0]), /* 1 */
	asn_DEF_ieee_binary32_w_tags_3,	/* Same as above */
	sizeof(asn_DEF_ieee_binary32_w_tags_3)
		/sizeof(asn_DEF_ieee_binary32_w_tags_3[0]), /* 1 */
	{ 0, 0, ieee_binary32_w_3_constraint },
	0, 0,	/* No members */
	&asn_SPC_ieee_binary32_w_specs_3	/* Additional specs */
};

static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_0w_specs_4 = {
	4	/* Use 'float' type. */
};
static const ber_tlv_tag_t asn_DEF_ieee_binary32_0w_tags_4[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_ieee_binary32_0w_4 = {
	"ieee-binary32-0w",
	"ieee-binary32-0w",
	&asn_OP_NativeReal,
	asn_DEF_ieee_binary32_0w_tags_4,
	sizeof(asn_DEF_ieee_binary32_0w_tags_4)
		/sizeof(asn_DEF_ieee_binary32_0w_tags_4[0]), /* 1 */
	asn_DEF_ieee_binary32_0w_tags_4,	/* Same as above */
	sizeof(asn_DEF_ieee_binary32_0w_tags_4)
		/sizeof(asn_DEF_ieee_binary32_0w_tags_4[0]), /* 1 */
	{ 0, 0, ieee_binary32_0w_4_constraint },
	0, 0,	/* No members */
	&asn_SPC_ieee_binary32_0w_specs_4	/* Additional specs */
};

static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_w0_specs_5 = {
	4	/* Use 'float' type. */
};
static const ber_tlv_tag_t asn_DEF_ieee_binary32_w0_tags_5[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
};
static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w0_5 = {
	"ieee-binary32-w0",
	"ieee-binary32-w0",
	&asn_OP_NativeReal,
	asn_DEF_ieee_binary32_w0_tags_5,
	sizeof(asn_DEF_ieee_binary32_w0_tags_5)
		/sizeof(asn_DEF_ieee_binary32_w0_tags_5[0]), /* 1 */
	asn_DEF_ieee_binary32_w0_tags_5,	/* Same as above */
	sizeof(asn_DEF_ieee_binary32_w0_tags_5)
		/sizeof(asn_DEF_ieee_binary32_w0_tags_5[0]), /* 1 */
	{ 0, 0, ieee_binary32_w0_5_constraint },
	0, 0,	/* No members */
	&asn_SPC_ieee_binary32_w0_specs_5	/* Additional specs */
};

static asn_TYPE_member_t asn_MBR_Test_1[] = {
	{ ATF_NOFLAGS, 0, offsetof(struct Test, indirect_ieee_binary32),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_Indirect_IEEE_binary32,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "indirect-ieee-binary32"
		},
	{ ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_w),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_IEEE_binary32_w,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "ieee-binary32-w"
		},
	{ ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_0w),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_IEEE_binary32_0w,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "ieee-binary32-0w"
		},
	{ ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_w0),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_IEEE_binary32_w0,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "ieee-binary32-w0"
		},
	{ ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_w),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_IEEE_binary64_w,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "ieee-binary64-w"
		},
	{ ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_0w),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_IEEE_binary64_0w,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "ieee-binary64-0w"
		},
	{ ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_w0),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_IEEE_binary64_w0,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "ieee-binary64-w0"
		},
};
static const ber_tlv_tag_t asn_DEF_Test_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
static const asn_TYPE_tag2member_t asn_MAP_Test_tag2el_1[] = {
    { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 0, 0, 6 }, /* indirect-ieee-binary32 */
    { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 1, -1, 5 }, /* ieee-binary32-w */
    { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 2, -2, 4 }, /* ieee-binary32-0w */
    { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 3, -3, 3 }, /* ieee-binary32-w0 */
    { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 4, -4, 2 }, /* ieee-binary64-w */
    { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 5, -5, 1 }, /* ieee-binary64-0w */
    { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 6, -6, 0 } /* ieee-binary64-w0 */
};
static asn_SEQUENCE_specifics_t asn_SPC_Test_specs_1 = {
	sizeof(struct Test),
	offsetof(struct Test, _asn_ctx),
	.tag2el = asn_MAP_Test_tag2el_1,
	.tag2el_count = 7,	/* Count of tags in the map */
	0, 0, 0,	/* Optional elements (not needed) */
	-1,	/* First extension addition */
};
asn_TYPE_descriptor_t asn_DEF_Test = {
	"Test",
	"Test",
	&asn_OP_SEQUENCE,
	asn_DEF_Test_tags_1,
	sizeof(asn_DEF_Test_tags_1)
		/sizeof(asn_DEF_Test_tags_1[0]), /* 1 */
	asn_DEF_Test_tags_1,	/* Same as above */
	sizeof(asn_DEF_Test_tags_1)
		/sizeof(asn_DEF_Test_tags_1[0]), /* 1 */
	{ 0, 0, SEQUENCE_constraint },
	asn_MBR_Test_1,
	7,	/* Elements count */
	&asn_SPC_Test_specs_1	/* Additional specs */
};