
/*** <<< INCLUDES [Collection] >>> ***/

#include <REAL.h>
#include <asn_SET_OF.h>
#include <constr_SET_OF.h>
#include <IA5String.h>

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

typedef struct Collection_16P0 {
	A_SET_OF(REAL_t) list;
	
	/* Context for parsing across buffer boundaries */
	asn_struct_ctx_t _asn_ctx;
} Collection_16P0_t;
typedef struct Collection_16P1 {
	A_SET_OF(IA5String_t) list;
	
	/* Context for parsing across buffer boundaries */
	asn_struct_ctx_t _asn_ctx;
} Collection_16P1_t;

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

extern asn_TYPE_descriptor_t asn_DEF_Collection_16P0;
extern asn_SET_OF_specifics_t asn_SPC_Collection_16P0_specs_1;
extern asn_TYPE_member_t asn_MBR_Collection_16P0_1[1];
extern asn_TYPE_descriptor_t asn_DEF_Collection_16P1;
extern asn_SET_OF_specifics_t asn_SPC_Collection_16P1_specs_3;
extern asn_TYPE_member_t asn_MBR_Collection_16P1_3[1];

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

asn_TYPE_member_t asn_MBR_Collection_16P0_1[] = {
	{ ATF_POINTER, 0, 0,
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_REAL,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = ""
		},
};
static const ber_tlv_tag_t asn_DEF_Collection_16P0_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
asn_SET_OF_specifics_t asn_SPC_Collection_16P0_specs_1 = {
	sizeof(struct Collection_16P0),
	offsetof(struct Collection_16P0, _asn_ctx),
	0,	/* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_Collection_16P0 = {
	"Collection",
	"Collection",
	&asn_OP_SET_OF,
	asn_DEF_Collection_16P0_tags_1,
	sizeof(asn_DEF_Collection_16P0_tags_1)
		/sizeof(asn_DEF_Collection_16P0_tags_1[0]), /* 1 */
	asn_DEF_Collection_16P0_tags_1,	/* Same as above */
	sizeof(asn_DEF_Collection_16P0_tags_1)
		/sizeof(asn_DEF_Collection_16P0_tags_1[0]), /* 1 */
	{ 0, 0, SET_OF_constraint },
	asn_MBR_Collection_16P0_1,
	1,	/* Single element */
	&asn_SPC_Collection_16P0_specs_1	/* Additional specs */
};

asn_TYPE_member_t asn_MBR_Collection_16P1_3[] = {
	{ ATF_POINTER, 0, 0,
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_IA5String,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = ""
		},
};
static const ber_tlv_tag_t asn_DEF_Collection_16P1_tags_3[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
asn_SET_OF_specifics_t asn_SPC_Collection_16P1_specs_3 = {
	sizeof(struct Collection_16P1),
	offsetof(struct Collection_16P1, _asn_ctx),
	0,	/* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_Collection_16P1 = {
	"Collection",
	"Collection",
	&asn_OP_SET_OF,
	asn_DEF_Collection_16P1_tags_3,
	sizeof(asn_DEF_Collection_16P1_tags_3)
		/sizeof(asn_DEF_Collection_16P1_tags_3[0]), /* 1 */
	asn_DEF_Collection_16P1_tags_3,	/* Same as above */
	sizeof(asn_DEF_Collection_16P1_tags_3)
		/sizeof(asn_DEF_Collection_16P1_tags_3[0]), /* 1 */
	{ 0, 0, SET_OF_constraint },
	asn_MBR_Collection_16P1_3,
	1,	/* Single element */
	&asn_SPC_Collection_16P1_specs_3	/* Additional specs */
};


/*** <<< INCLUDES [Bunch] >>> ***/

#include "Collection.h"
#include <constr_SEQUENCE.h>

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

typedef struct Bunch {
	Collection_16P0_t	 field_REAL;
	Collection_16P1_t	 field_IA5String;
	
	/* Context for parsing across buffer boundaries */
	asn_struct_ctx_t _asn_ctx;
} Bunch_t;

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

extern asn_TYPE_descriptor_t asn_DEF_Bunch;

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

static asn_TYPE_member_t asn_MBR_Bunch_1[] = {
	{ ATF_NOFLAGS, 0, offsetof(struct Bunch, field_REAL),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_Collection_16P0,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "field-REAL"
		},
	{ ATF_NOFLAGS, 0, offsetof(struct Bunch, field_IA5String),
		.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
		.tag_mode = 0,
		.type = &asn_DEF_Collection_16P1,
		.type_selector = 0,
		{ .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
		0, 0, /* No default value */
		.name = "field-IA5String"
		},
};
static const ber_tlv_tag_t asn_DEF_Bunch_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
static const asn_TYPE_tag2member_t asn_MAP_Bunch_tag2el_1[] = {
    { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 1 }, /* field-REAL */
    { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 1, -1, 0 } /* field-IA5String */
};
static asn_SEQUENCE_specifics_t asn_SPC_Bunch_specs_1 = {
	sizeof(struct Bunch),
	offsetof(struct Bunch, _asn_ctx),
	.tag2el = asn_MAP_Bunch_tag2el_1,
	.tag2el_count = 2,	/* Count of tags in the map */
	0, 0, 0,	/* Optional elements (not needed) */
	-1,	/* First extension addition */
};
asn_TYPE_descriptor_t asn_DEF_Bunch = {
	"Bunch",
	"Bunch",
	&asn_OP_SEQUENCE,
	asn_DEF_Bunch_tags_1,
	sizeof(asn_DEF_Bunch_tags_1)
		/sizeof(asn_DEF_Bunch_tags_1[0]), /* 1 */
	asn_DEF_Bunch_tags_1,	/* Same as above */
	sizeof(asn_DEF_Bunch_tags_1)
		/sizeof(asn_DEF_Bunch_tags_1[0]), /* 1 */
	{ 0, 0, SEQUENCE_constraint },
	asn_MBR_Bunch_1,
	2,	/* Elements count */
	&asn_SPC_Bunch_specs_1	/* Additional specs */
};

