Build ASN1_M2AP_LIB in separate module from generated source

CMakeLists.txt

@@ -430,55 +430,14 @@ target_link_libraries(NGAP_GNB PUBLIC ASN1_NGAP_LIB)
 target_include_directories(NGAP_GNB PUBLIC "${NGAP_DIR}")
 
 #M2AP
-# Same limitation as described in RRC/S1AP: unknown generated file list
-# so we generate it at cmake time
 ##############
-add_list1_option(M2AP_RELEASE R14 "M2AP ASN.1 grammar version" R14)
+set(M2AP_RELEASE R14)
 
 set(M2AP_DIR ${OPENAIR2_DIR}/M2AP)
-if (${M2AP_RELEASE} STREQUAL "R8")
-  make_version(M2AP_VERSION 8 9 0)
-  set(M2AP_ASN_FILES m2ap-8.9.0.asn1)
-elseif (${M2AP_RELEASE} STREQUAL "R11")
-  make_version(M2AP_VERSION 11 9 0)
-  set(M2AP_ASN_FILES m2ap-11.9.0.asn1)
-elseif (${M2AP_RELEASE} STREQUAL "R12")
-  make_version(M2AP_VERSION 12 9 0)
-  set(M2AP_ASN_FILES m2ap-12.9.0.asn1)
-elseif (${M2AP_RELEASE} STREQUAL "R14")
-  make_version(M2AP_VERSION 14 0 0)
-  set(M2AP_ASN_FILES m2ap-14.0.0.asn1)
-elseif (${M2AP_RELEASE} STREQUAL "R15")
-  make_version(M2AP_VERSION 15 1 0)
-  set(M2AP_ASN_FILES m2ap-15.1.0.asn1)
-endif(${M2AP_RELEASE} STREQUAL "R8")
 add_definitions(-DM2AP_VERSION=${M2AP_VERSION})
-set(M2AP_ASN_DIR ${M2AP_DIR}/MESSAGES/ASN1/${M2AP_RELEASE})
-set(M2AP_C_DIR ${asn1_generated_dir}/M2AP_${M2AP_RELEASE})
-
-# Warning: if you modify ASN.1 source file to generate new C files, cmake should be re-run instead of make
-execute_process(COMMAND ${OPENAIR_CMAKE}/tools/make_asn1c_includes.sh "${M2AP_C_DIR}" "${M2AP_ASN_DIR}/${M2AP_ASN_FILES}"  "M2AP_" -fno-include-deps -DEMIT_ASN_DEBUG=1
-                RESULT_VARIABLE ret)
-if (NOT ${ret} STREQUAL 0)
-  message(FATAL_ERROR "${ret}: error")
-endif (NOT ${ret} STREQUAL 0)
-
-file(GLOB M2AP_source ${M2AP_C_DIR}/*.c)
-
-add_custom_target (
-  m2_flag ALL
-  COMMAND ${OPENAIR_CMAKE}/tools/make_asn1c_includes.sh "${M2AP_C_DIR}" "${M2AP_ASN_DIR}/${M2AP_ASN_FILES}"  "M2AP_" -fno-include-deps
-  DEPENDS ${M2AP_ASN_DIR}/${M2AP_ASN_FILES}
-  )
-
-add_library(M2AP_LIB
-  ${M2AP_source}
-  ${M2AP_DIR}/m2ap_common.c
-  )
-add_dependencies(M2AP_LIB m2_flag)
 
-include_directories ("${M2AP_C_DIR}")
-include_directories ("${M2AP_DIR}")
+add_library(M2AP_LIB ${M2AP_DIR}/m2ap_common.c)
+target_link_libraries(M2AP_LIB PUBLIC ASN1_M2AP_LIB)
 
 add_library(M2AP_ENB
   ${M2AP_DIR}/m2ap_eNB.c
@@ -497,7 +456,8 @@ add_library(M2AP_ENB
   ${M2AP_DIR}/m2ap_MCE_interface_management.c
   ${M2AP_DIR}/m2ap_eNB_interface_management.c
  )
-add_dependencies(M2AP_ENB m2_flag)
+target_link_libraries(M2AP_ENB PUBLIC ASN1_M2AP_LIB)
+target_include_directories(M2AP_ENB PUBLIC "${M2AP_DIR}")
 
 #M3AP
 # Same limitation as described in RRC/S1AP: unknown generated file list
@@ -566,6 +526,7 @@ add_library(M3AP_ENB
   ${M3AP_DIR}/m3ap_timers.c
   )
 add_dependencies(M3AP_ENB m3_flag)
+target_link_libraries(M3AP_ENB PRIVATE M2AP_ENB)
 
 #X2AP
 ##############
@@ -1939,7 +1900,7 @@ add_library(L2
   ${ENB_APP_SRC}
   ${MCE_APP_SRC}
   )
-add_dependencies(L2 m2_flag m3_flag)
+add_dependencies(L2 m3_flag)
 target_link_libraries(L2 PRIVATE ASN1_S1AP_LIB ASN1_F1AP_LIB)
 
 add_library(MAC_NR
@@ -1960,6 +1921,7 @@ add_library(L2_NR
   ${GNB_APP_SRC}
   )
 target_link_libraries(L2_NR PRIVATE ASN1_S1AP_LIB ASN1_NGAP_LIB NGAP_GNB)
+target_include_directories(L2_NR PRIVATE M2AP_ENB)
 
 add_library(L2_LTE_NR
   ${L2_RRC_SRC}
@@ -2037,7 +1999,7 @@ set (MME_APP_SRC
   ${OPENAIR3_DIR}/MME_APP/mme_config.c
 )
 add_library(MME_APP ${MME_APP_SRC})
-add_dependencies(MME_APP m2_flag m3_flag)
+add_dependencies(MME_APP m3_flag)
 
 set(SCTP_SRC
   ${OPENAIR3_DIR}/SCTP/sctp_common.c

openair2/CMakeLists.txt

 add_subdirectory(F1AP)
+add_subdirectory(M2AP)
 add_subdirectory(RRC)
 add_subdirectory(X2AP)

openair2/M2AP/CMakeLists.txt

+add_subdirectory(MESSAGES)

openair2/M2AP/MESSAGES/ASN1/CMakeLists.txt

+file(GLOB lte_m2ap_source R14/m2ap-14.0.0.gen/*.c)
+add_library(ASN1_M2AP_LIB ${lte_m2ap_source})
+target_include_directories(ASN1_M2AP_LIB PUBLIC "R14/m2ap-14.0.0.gen/")
+target_compile_options(ASN1_M2AP_LIB PRIVATE -DASN_DISABLE_OER_SUPPORT -w)

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/ANY.h

+/*-
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_TYPE_ANY_H
+#define ASN_TYPE_ANY_H
+
+#include <OCTET_STRING.h>	/* Implemented via OCTET STRING type */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ANY {
+	uint8_t *buf;	/* BER-encoded ANY contents */
+	int size;	/* Size of the above buffer */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} ANY_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_ANY;
+extern asn_TYPE_operation_t asn_OP_ANY;
+extern asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs;
+
+asn_struct_free_f ANY_free;
+asn_struct_print_f ANY_print;
+ber_type_decoder_f ANY_decode_ber;
+der_type_encoder_f ANY_encode_der;
+xer_type_encoder_f ANY_encode_xer;
+per_type_decoder_f ANY_decode_uper;
+per_type_encoder_f ANY_encode_uper;
+per_type_decoder_f ANY_decode_aper;
+per_type_encoder_f ANY_encode_aper;
+
+#define ANY_free         OCTET_STRING_free
+#define ANY_print        OCTET_STRING_print
+#define ANY_compare      OCTET_STRING_compare
+#define ANY_constraint   asn_generic_no_constraint
+#define ANY_decode_ber   OCTET_STRING_decode_ber
+#define ANY_encode_der   OCTET_STRING_encode_der
+#define ANY_decode_xer   OCTET_STRING_decode_xer_hex
+
+/******************************
+ * Handy conversion routines. *
+ ******************************/
+
+/* Convert another ASN.1 type into the ANY. This implies DER encoding. */
+int ANY_fromType(ANY_t *, asn_TYPE_descriptor_t *td, void *struct_ptr);
+int ANY_fromType_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr);
+ANY_t *ANY_new_fromType(asn_TYPE_descriptor_t *td, void *struct_ptr);
+ANY_t *ANY_new_fromType_aper(asn_TYPE_descriptor_t *td, void *sptr);
+
+/* Convert the contents of the ANY type into the specified type. */
+int ANY_to_type(ANY_t *, asn_TYPE_descriptor_t *td, void **struct_ptr);
+int ANY_to_type_aper(ANY_t *, asn_TYPE_descriptor_t *td, void **struct_ptr);
+
+#define	ANY_fromBuf(s, buf, size)	OCTET_STRING_fromBuf((s), (buf), (size))
+#define	ANY_new_fromBuf(buf, size)	OCTET_STRING_new_fromBuf(	\
+						&asn_DEF_ANY, (buf), (size))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* ASN_TYPE_ANY_H */

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/BIT_STRING.h

+/*-
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_BIT_STRING_H_
+#define	_BIT_STRING_H_
+
+#include <OCTET_STRING.h>	/* Some help from OCTET STRING */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct BIT_STRING_s {
+	uint8_t *buf;	/* BIT STRING body */
+	size_t size;	/* Size of the above buffer */
+
+	int bits_unused;/* Unused trailing bits in the last octet (0..7) */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} BIT_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
+extern asn_TYPE_operation_t asn_OP_BIT_STRING;
+extern asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs;
+
+asn_struct_print_f BIT_STRING_print;	/* Human-readable output */
+asn_struct_compare_f BIT_STRING_compare;
+asn_constr_check_f BIT_STRING_constraint;
+xer_type_encoder_f BIT_STRING_encode_xer;
+oer_type_decoder_f BIT_STRING_decode_oer;
+oer_type_encoder_f BIT_STRING_encode_oer;
+per_type_decoder_f BIT_STRING_decode_uper;
+per_type_encoder_f BIT_STRING_encode_uper;
+asn_random_fill_f  BIT_STRING_random_fill;
+
+#define BIT_STRING_free              OCTET_STRING_free
+#define BIT_STRING_decode_ber        OCTET_STRING_decode_ber
+#define BIT_STRING_encode_der        OCTET_STRING_encode_der
+#define BIT_STRING_decode_xer        OCTET_STRING_decode_xer_binary
+#define BIT_STRING_decode_aper       OCTET_STRING_decode_aper
+#define BIT_STRING_encode_aper       OCTET_STRING_encode_aper
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BIT_STRING_H_ */

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/INTEGER.h

+/*-
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_INTEGER_H_
+#define	_INTEGER_H_
+
+#include <asn_application.h>
+#include <asn_codecs_prim.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
+extern asn_TYPE_operation_t asn_OP_INTEGER;
+
+/* Map with <tag> to integer value association */
+typedef struct asn_INTEGER_enum_map_s {
+	long		 nat_value;	/* associated native integer value */
+	size_t		 enum_len;	/* strlen("tag") */
+	const char	*enum_name;	/* "tag" */
+} asn_INTEGER_enum_map_t;
+
+/* This type describes an enumeration for INTEGER and ENUMERATED types */
+typedef struct asn_INTEGER_specifics_s {
+	const asn_INTEGER_enum_map_t *value2enum;	/* N -> "tag"; sorted by N */
+	const unsigned int *enum2value;		/* "tag" => N; sorted by tag */
+	int map_count;				/* Elements in either map */
+	int extension;				/* This map is extensible */
+	int strict_enumeration;			/* Enumeration set is fixed */
+	int field_width;			/* Size of native integer */
+	int field_unsigned;			/* Signed=0, unsigned=1 */
+} asn_INTEGER_specifics_t;
+
+#define INTEGER_free    ASN__PRIMITIVE_TYPE_free
+#define INTEGER_decode_ber	ber_decode_primitive
+#define INTEGER_constraint	asn_generic_no_constraint
+asn_struct_print_f INTEGER_print;
+asn_struct_compare_f INTEGER_compare;
+der_type_encoder_f INTEGER_encode_der;
+xer_type_decoder_f INTEGER_decode_xer;
+xer_type_encoder_f INTEGER_encode_xer;
+oer_type_decoder_f INTEGER_decode_oer;
+oer_type_encoder_f INTEGER_encode_oer;
+per_type_decoder_f INTEGER_decode_uper;
+per_type_encoder_f INTEGER_encode_uper;
+per_type_decoder_f INTEGER_decode_aper;
+per_type_encoder_f INTEGER_encode_aper;
+asn_random_fill_f  INTEGER_random_fill;
+
+/***********************************
+ * Some handy conversion routines. *
+ ***********************************/
+
+/*
+ * Natiwe size-independent conversion of native integers to/from INTEGER.
+ * (l_size) is in bytes.
+ * Returns 0 if it was possible to convert, -1 otherwise.
+ * -1/EINVAL: Mandatory argument missing
+ * -1/ERANGE: Value encoded is out of range for long representation
+ * -1/ENOMEM: Memory allocation failed (in asn_*2INTEGER()).
+ */
+int asn_INTEGER2imax(const INTEGER_t *i, intmax_t *l);
+int asn_INTEGER2umax(const INTEGER_t *i, uintmax_t *l);
+int asn_imax2INTEGER(INTEGER_t *i, intmax_t l);
+int asn_umax2INTEGER(INTEGER_t *i, uintmax_t l);
+
+/*
+ * Size-specific conversion helpers.
+ */
+int asn_INTEGER2long(const INTEGER_t *i, long *l);
+int asn_INTEGER2ulong(const INTEGER_t *i, unsigned long *l);
+int asn_long2INTEGER(INTEGER_t *i, long l);
+int asn_ulong2INTEGER(INTEGER_t *i, unsigned long l);
+int asn_int642INTEGER(INTEGER_t *i, int64_t l);
+int asn_uint642INTEGER(INTEGER_t *i, uint64_t l);
+
+/* A version of strtol/strtoimax(3) with nicer error reporting. */
+enum asn_strtox_result_e {
+    ASN_STRTOX_ERROR_RANGE = -3,  /* Input outside of supported numeric range */
+    ASN_STRTOX_ERROR_INVAL = -2,  /* Invalid data encountered (e.g., "+-") */
+    ASN_STRTOX_EXPECT_MORE = -1,  /* More data expected (e.g. "+") */
+    ASN_STRTOX_OK          =  0,  /* Conversion succeded, number ends at (*end) */
+    ASN_STRTOX_EXTRA_DATA  =  1   /* Conversion succeded, but the string has extra stuff */
+};
+enum asn_strtox_result_e asn_strtol_lim(const char *str, const char **end,
+                                        long *l);
+enum asn_strtox_result_e asn_strtoul_lim(const char *str, const char **end,
+                                         unsigned long *l);
+enum asn_strtox_result_e asn_strtoimax_lim(const char *str, const char **end,
+                                           intmax_t *l);
+enum asn_strtox_result_e asn_strtoumax_lim(const char *str, const char **end,
+                                           uintmax_t *l);
+
+/*
+ * Convert the integer value into the corresponding enumeration map entry.
+ */
+const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(
+    const asn_INTEGER_specifics_t *specs, long value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _INTEGER_H_ */

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Active-MBMS-Session-List.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-PDU-Contents"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_Active-MBMS-Session-List.h"
+
+#include "M2AP_ProtocolIE-Container.h"
+asn_per_constraints_t asn_PER_type_M2AP_Active_MBMS_Session_List_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 5,  5,  1,  29 }	/* (SIZE(1..29)) */,
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_M2AP_Active_MBMS_Session_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_M2AP_ProtocolIE_Container_1820P31,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_Active_MBMS_Session_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+asn_SET_OF_specifics_t asn_SPC_M2AP_Active_MBMS_Session_List_specs_1 = {
+	sizeof(struct M2AP_Active_MBMS_Session_List),
+	offsetof(struct M2AP_Active_MBMS_Session_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_Active_MBMS_Session_List = {
+	"Active-MBMS-Session-List",
+	"Active-MBMS-Session-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_M2AP_Active_MBMS_Session_List_tags_1,
+	sizeof(asn_DEF_M2AP_Active_MBMS_Session_List_tags_1)
+		/sizeof(asn_DEF_M2AP_Active_MBMS_Session_List_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_Active_MBMS_Session_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_Active_MBMS_Session_List_tags_1)
+		/sizeof(asn_DEF_M2AP_Active_MBMS_Session_List_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_Active_MBMS_Session_List_constr_1, SEQUENCE_OF_constraint },
+	asn_MBR_M2AP_Active_MBMS_Session_List_1,
+	1,	/* Single element */
+	&asn_SPC_M2AP_Active_MBMS_Session_List_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Active-MBMS-Session-List.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-PDU-Contents"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_Active_MBMS_Session_List_H_
+#define	_M2AP_Active_MBMS_Session_List_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct M2AP_ProtocolIE_Container;
+
+/* M2AP_Active-MBMS-Session-List */
+typedef struct M2AP_Active_MBMS_Session_List {
+	A_SEQUENCE_OF(struct M2AP_ProtocolIE_Container) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} M2AP_Active_MBMS_Session_List_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_Active_MBMS_Session_List;
+extern asn_SET_OF_specifics_t asn_SPC_M2AP_Active_MBMS_Session_List_specs_1;
+extern asn_TYPE_member_t asn_MBR_M2AP_Active_MBMS_Session_List_1[1];
+extern asn_per_constraints_t asn_PER_type_M2AP_Active_MBMS_Session_List_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_Active_MBMS_Session_List_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_AllocatedSubframesEnd.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_AllocatedSubframesEnd.h"
+
+int
+M2AP_AllocatedSubframesEnd_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 1535)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_AllocatedSubframesEnd_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 11,  11,  0,  1535 }	/* (0..1535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_AllocatedSubframesEnd_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_AllocatedSubframesEnd = {
+	"AllocatedSubframesEnd",
+	"AllocatedSubframesEnd",
+	&asn_OP_NativeInteger,
+	asn_DEF_M2AP_AllocatedSubframesEnd_tags_1,
+	sizeof(asn_DEF_M2AP_AllocatedSubframesEnd_tags_1)
+		/sizeof(asn_DEF_M2AP_AllocatedSubframesEnd_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_AllocatedSubframesEnd_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_AllocatedSubframesEnd_tags_1)
+		/sizeof(asn_DEF_M2AP_AllocatedSubframesEnd_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_AllocatedSubframesEnd_constr_1, M2AP_AllocatedSubframesEnd_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_AllocatedSubframesEnd.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_AllocatedSubframesEnd_H_
+#define	_M2AP_AllocatedSubframesEnd_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* M2AP_AllocatedSubframesEnd */
+typedef long	 M2AP_AllocatedSubframesEnd_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_AllocatedSubframesEnd_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_AllocatedSubframesEnd;
+asn_struct_free_f M2AP_AllocatedSubframesEnd_free;
+asn_struct_print_f M2AP_AllocatedSubframesEnd_print;
+asn_constr_check_f M2AP_AllocatedSubframesEnd_constraint;
+ber_type_decoder_f M2AP_AllocatedSubframesEnd_decode_ber;
+der_type_encoder_f M2AP_AllocatedSubframesEnd_encode_der;
+xer_type_decoder_f M2AP_AllocatedSubframesEnd_decode_xer;
+xer_type_encoder_f M2AP_AllocatedSubframesEnd_encode_xer;
+per_type_decoder_f M2AP_AllocatedSubframesEnd_decode_uper;
+per_type_encoder_f M2AP_AllocatedSubframesEnd_encode_uper;
+per_type_decoder_f M2AP_AllocatedSubframesEnd_decode_aper;
+per_type_encoder_f M2AP_AllocatedSubframesEnd_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_AllocatedSubframesEnd_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_AllocationAndRetentionPriority.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_AllocationAndRetentionPriority.h"
+
+#include "M2AP_ProtocolExtensionContainer.h"
+asn_TYPE_member_t asn_MBR_M2AP_AllocationAndRetentionPriority_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_AllocationAndRetentionPriority, priorityLevel),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_PriorityLevel,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"priorityLevel"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_AllocationAndRetentionPriority, pre_emptionCapability),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_Pre_emptionCapability,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"pre-emptionCapability"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_AllocationAndRetentionPriority, pre_emptionVulnerability),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_Pre_emptionVulnerability,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"pre-emptionVulnerability"
+		},
+	{ ATF_POINTER, 1, offsetof(struct M2AP_AllocationAndRetentionPriority, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_ProtocolExtensionContainer_1871P4,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_M2AP_AllocationAndRetentionPriority_oms_1[] = { 3 };
+static const ber_tlv_tag_t asn_DEF_M2AP_AllocationAndRetentionPriority_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_M2AP_AllocationAndRetentionPriority_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* priorityLevel */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* pre-emptionCapability */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* pre-emptionVulnerability */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* iE-Extensions */
+};
+asn_SEQUENCE_specifics_t asn_SPC_M2AP_AllocationAndRetentionPriority_specs_1 = {
+	sizeof(struct M2AP_AllocationAndRetentionPriority),
+	offsetof(struct M2AP_AllocationAndRetentionPriority, _asn_ctx),
+	asn_MAP_M2AP_AllocationAndRetentionPriority_tag2el_1,
+	4,	/* Count of tags in the map */
+	asn_MAP_M2AP_AllocationAndRetentionPriority_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	-1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_AllocationAndRetentionPriority = {
+	"AllocationAndRetentionPriority",
+	"AllocationAndRetentionPriority",
+	&asn_OP_SEQUENCE,
+	asn_DEF_M2AP_AllocationAndRetentionPriority_tags_1,
+	sizeof(asn_DEF_M2AP_AllocationAndRetentionPriority_tags_1)
+		/sizeof(asn_DEF_M2AP_AllocationAndRetentionPriority_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_AllocationAndRetentionPriority_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_AllocationAndRetentionPriority_tags_1)
+		/sizeof(asn_DEF_M2AP_AllocationAndRetentionPriority_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_M2AP_AllocationAndRetentionPriority_1,
+	4,	/* Elements count */
+	&asn_SPC_M2AP_AllocationAndRetentionPriority_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_AllocationAndRetentionPriority.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_AllocationAndRetentionPriority_H_
+#define	_M2AP_AllocationAndRetentionPriority_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "M2AP_PriorityLevel.h"
+#include "M2AP_Pre-emptionCapability.h"
+#include "M2AP_Pre-emptionVulnerability.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct M2AP_ProtocolExtensionContainer;
+
+/* M2AP_AllocationAndRetentionPriority */
+typedef struct M2AP_AllocationAndRetentionPriority {
+	M2AP_PriorityLevel_t	 priorityLevel;
+	M2AP_Pre_emptionCapability_t	 pre_emptionCapability;
+	M2AP_Pre_emptionVulnerability_t	 pre_emptionVulnerability;
+	struct M2AP_ProtocolExtensionContainer	*iE_Extensions;	/* OPTIONAL */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} M2AP_AllocationAndRetentionPriority_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_AllocationAndRetentionPriority;
+extern asn_SEQUENCE_specifics_t asn_SPC_M2AP_AllocationAndRetentionPriority_specs_1;
+extern asn_TYPE_member_t asn_MBR_M2AP_AllocationAndRetentionPriority_1[4];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_AllocationAndRetentionPriority_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_BitRate.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_BitRate.h"
+
+int
+M2AP_BitRate_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const INTEGER_t *st = (const INTEGER_t *)sptr;
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(asn_INTEGER2long(st, &value)) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value too large (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if((value >= 0 && value <= 10000000000)) {
+		/* 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 INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_BitRate_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 34, -1,  0,  10000000000 }	/* (0..10000000000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_BitRate_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_BitRate = {
+	"BitRate",
+	"BitRate",
+	&asn_OP_INTEGER,
+	asn_DEF_M2AP_BitRate_tags_1,
+	sizeof(asn_DEF_M2AP_BitRate_tags_1)
+		/sizeof(asn_DEF_M2AP_BitRate_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_BitRate_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_BitRate_tags_1)
+		/sizeof(asn_DEF_M2AP_BitRate_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_BitRate_constr_1, M2AP_BitRate_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_BitRate.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_BitRate_H_
+#define	_M2AP_BitRate_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* M2AP_BitRate */
+typedef INTEGER_t	 M2AP_BitRate_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_BitRate_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_BitRate;
+asn_struct_free_f M2AP_BitRate_free;
+asn_struct_print_f M2AP_BitRate_print;
+asn_constr_check_f M2AP_BitRate_constraint;
+ber_type_decoder_f M2AP_BitRate_decode_ber;
+der_type_encoder_f M2AP_BitRate_encode_der;
+xer_type_decoder_f M2AP_BitRate_decode_xer;
+xer_type_encoder_f M2AP_BitRate_encode_xer;
+per_type_decoder_f M2AP_BitRate_decode_uper;
+per_type_encoder_f M2AP_BitRate_encode_uper;
+per_type_decoder_f M2AP_BitRate_decode_aper;
+per_type_encoder_f M2AP_BitRate_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_BitRate_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Cause.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_Cause.h"
+
+asn_per_constraints_t asn_PER_type_M2AP_Cause_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  4 }	/* (0..4,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_M2AP_Cause_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_Cause, choice.radioNetwork),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_CauseRadioNetwork,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"radioNetwork"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_Cause, choice.transport),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_CauseTransport,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"transport"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_Cause, choice.nAS),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_CauseNAS,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"nAS"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_Cause, choice.protocol),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_CauseProtocol,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"protocol"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_Cause, choice.misc),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_CauseMisc,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"misc"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_M2AP_Cause_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* radioNetwork */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* transport */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* nAS */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* protocol */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* misc */
+};
+asn_CHOICE_specifics_t asn_SPC_M2AP_Cause_specs_1 = {
+	sizeof(struct M2AP_Cause),
+	offsetof(struct M2AP_Cause, _asn_ctx),
+	offsetof(struct M2AP_Cause, present),
+	sizeof(((struct M2AP_Cause *)0)->present),
+	asn_MAP_M2AP_Cause_tag2el_1,
+	5,	/* Count of tags in the map */
+	0, 0,
+	5	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_Cause = {
+	"Cause",
+	"Cause",
+	&asn_OP_CHOICE,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	{ 0, &asn_PER_type_M2AP_Cause_constr_1, CHOICE_constraint },
+	asn_MBR_M2AP_Cause_1,
+	5,	/* Elements count */
+	&asn_SPC_M2AP_Cause_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Cause.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_Cause_H_
+#define	_M2AP_Cause_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "M2AP_CauseRadioNetwork.h"
+#include "M2AP_CauseTransport.h"
+#include "M2AP_CauseNAS.h"
+#include "M2AP_CauseProtocol.h"
+#include "M2AP_CauseMisc.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_Cause_PR {
+	M2AP_Cause_PR_NOTHING,	/* No components present */
+	M2AP_Cause_PR_radioNetwork,
+	M2AP_Cause_PR_transport,
+	M2AP_Cause_PR_nAS,
+	M2AP_Cause_PR_protocol,
+	M2AP_Cause_PR_misc
+	/* Extensions may appear below */
+	
+} M2AP_Cause_PR;
+
+/* M2AP_Cause */
+typedef struct M2AP_Cause {
+	M2AP_Cause_PR present;
+	union M2AP_Cause_u {
+		M2AP_CauseRadioNetwork_t	 radioNetwork;
+		M2AP_CauseTransport_t	 transport;
+		M2AP_CauseNAS_t	 nAS;
+		M2AP_CauseProtocol_t	 protocol;
+		M2AP_CauseMisc_t	 misc;
+		/*
+		 * This type is extensible,
+		 * possible extensions are below.
+		 */
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} M2AP_Cause_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_Cause;
+extern asn_CHOICE_specifics_t asn_SPC_M2AP_Cause_specs_1;
+extern asn_TYPE_member_t asn_MBR_M2AP_Cause_1[5];
+extern asn_per_constraints_t asn_PER_type_M2AP_Cause_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_Cause_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseMisc.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_CauseMisc.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_CauseMisc_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  3 }	/* (0..3,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_M2AP_CauseMisc_value2enum_1[] = {
+	{ 0,	27,	"control-processing-overload" },
+	{ 1,	16,	"hardware-failure" },
+	{ 2,	15,	"om-intervention" },
+	{ 3,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_M2AP_CauseMisc_enum2value_1[] = {
+	0,	/* control-processing-overload(0) */
+	1,	/* hardware-failure(1) */
+	2,	/* om-intervention(2) */
+	3	/* unspecified(3) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseMisc_specs_1 = {
+	asn_MAP_M2AP_CauseMisc_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_M2AP_CauseMisc_enum2value_1,	/* N => "tag"; sorted by N */
+	4,	/* Number of elements in the maps */
+	5,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_CauseMisc_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_CauseMisc = {
+	"CauseMisc",
+	"CauseMisc",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_M2AP_CauseMisc_tags_1,
+	sizeof(asn_DEF_M2AP_CauseMisc_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseMisc_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_CauseMisc_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_CauseMisc_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseMisc_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_CauseMisc_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_M2AP_CauseMisc_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseMisc.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_CauseMisc_H_
+#define	_M2AP_CauseMisc_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_CauseMisc {
+	M2AP_CauseMisc_control_processing_overload	= 0,
+	M2AP_CauseMisc_hardware_failure	= 1,
+	M2AP_CauseMisc_om_intervention	= 2,
+	M2AP_CauseMisc_unspecified	= 3
+	/*
+	 * Enumeration is extensible
+	 */
+} e_M2AP_CauseMisc;
+
+/* M2AP_CauseMisc */
+typedef long	 M2AP_CauseMisc_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_CauseMisc_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_CauseMisc;
+extern const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseMisc_specs_1;
+asn_struct_free_f M2AP_CauseMisc_free;
+asn_struct_print_f M2AP_CauseMisc_print;
+asn_constr_check_f M2AP_CauseMisc_constraint;
+ber_type_decoder_f M2AP_CauseMisc_decode_ber;
+der_type_encoder_f M2AP_CauseMisc_encode_der;
+xer_type_decoder_f M2AP_CauseMisc_decode_xer;
+xer_type_encoder_f M2AP_CauseMisc_encode_xer;
+per_type_decoder_f M2AP_CauseMisc_decode_uper;
+per_type_encoder_f M2AP_CauseMisc_encode_uper;
+per_type_decoder_f M2AP_CauseMisc_decode_aper;
+per_type_encoder_f M2AP_CauseMisc_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_CauseMisc_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseNAS.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_CauseNAS.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_CauseNAS_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0,  0 }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_M2AP_CauseNAS_value2enum_1[] = {
+	{ 0,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_M2AP_CauseNAS_enum2value_1[] = {
+	0	/* unspecified(0) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseNAS_specs_1 = {
+	asn_MAP_M2AP_CauseNAS_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_M2AP_CauseNAS_enum2value_1,	/* N => "tag"; sorted by N */
+	1,	/* Number of elements in the maps */
+	2,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_CauseNAS_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_CauseNAS = {
+	"CauseNAS",
+	"CauseNAS",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_M2AP_CauseNAS_tags_1,
+	sizeof(asn_DEF_M2AP_CauseNAS_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseNAS_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_CauseNAS_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_CauseNAS_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseNAS_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_CauseNAS_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_M2AP_CauseNAS_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseNAS.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_CauseNAS_H_
+#define	_M2AP_CauseNAS_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_CauseNAS {
+	M2AP_CauseNAS_unspecified	= 0
+	/*
+	 * Enumeration is extensible
+	 */
+} e_M2AP_CauseNAS;
+
+/* M2AP_CauseNAS */
+typedef long	 M2AP_CauseNAS_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_CauseNAS_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_CauseNAS;
+extern const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseNAS_specs_1;
+asn_struct_free_f M2AP_CauseNAS_free;
+asn_struct_print_f M2AP_CauseNAS_print;
+asn_constr_check_f M2AP_CauseNAS_constraint;
+ber_type_decoder_f M2AP_CauseNAS_decode_ber;
+der_type_encoder_f M2AP_CauseNAS_encode_der;
+xer_type_decoder_f M2AP_CauseNAS_decode_xer;
+xer_type_encoder_f M2AP_CauseNAS_encode_xer;
+per_type_decoder_f M2AP_CauseNAS_decode_uper;
+per_type_encoder_f M2AP_CauseNAS_encode_uper;
+per_type_decoder_f M2AP_CauseNAS_decode_aper;
+per_type_encoder_f M2AP_CauseNAS_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_CauseNAS_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseProtocol.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_CauseProtocol.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_CauseProtocol_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  6 }	/* (0..6,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_M2AP_CauseProtocol_value2enum_1[] = {
+	{ 0,	21,	"transfer-syntax-error" },
+	{ 1,	28,	"abstract-syntax-error-reject" },
+	{ 2,	39,	"abstract-syntax-error-ignore-and-notify" },
+	{ 3,	42,	"message-not-compatible-with-receiver-state" },
+	{ 4,	14,	"semantic-error" },
+	{ 5,	49,	"abstract-syntax-error-falsely-constructed-message" },
+	{ 6,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_M2AP_CauseProtocol_enum2value_1[] = {
+	5,	/* abstract-syntax-error-falsely-constructed-message(5) */
+	2,	/* abstract-syntax-error-ignore-and-notify(2) */
+	1,	/* abstract-syntax-error-reject(1) */
+	3,	/* message-not-compatible-with-receiver-state(3) */
+	4,	/* semantic-error(4) */
+	0,	/* transfer-syntax-error(0) */
+	6	/* unspecified(6) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseProtocol_specs_1 = {
+	asn_MAP_M2AP_CauseProtocol_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_M2AP_CauseProtocol_enum2value_1,	/* N => "tag"; sorted by N */
+	7,	/* Number of elements in the maps */
+	8,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_CauseProtocol_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_CauseProtocol = {
+	"CauseProtocol",
+	"CauseProtocol",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_M2AP_CauseProtocol_tags_1,
+	sizeof(asn_DEF_M2AP_CauseProtocol_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseProtocol_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_CauseProtocol_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_CauseProtocol_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseProtocol_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_CauseProtocol_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_M2AP_CauseProtocol_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseProtocol.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_CauseProtocol_H_
+#define	_M2AP_CauseProtocol_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_CauseProtocol {
+	M2AP_CauseProtocol_transfer_syntax_error	= 0,
+	M2AP_CauseProtocol_abstract_syntax_error_reject	= 1,
+	M2AP_CauseProtocol_abstract_syntax_error_ignore_and_notify	= 2,
+	M2AP_CauseProtocol_message_not_compatible_with_receiver_state	= 3,
+	M2AP_CauseProtocol_semantic_error	= 4,
+	M2AP_CauseProtocol_abstract_syntax_error_falsely_constructed_message	= 5,
+	M2AP_CauseProtocol_unspecified	= 6
+	/*
+	 * Enumeration is extensible
+	 */
+} e_M2AP_CauseProtocol;
+
+/* M2AP_CauseProtocol */
+typedef long	 M2AP_CauseProtocol_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_CauseProtocol_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_CauseProtocol;
+extern const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseProtocol_specs_1;
+asn_struct_free_f M2AP_CauseProtocol_free;
+asn_struct_print_f M2AP_CauseProtocol_print;
+asn_constr_check_f M2AP_CauseProtocol_constraint;
+ber_type_decoder_f M2AP_CauseProtocol_decode_ber;
+der_type_encoder_f M2AP_CauseProtocol_encode_der;
+xer_type_decoder_f M2AP_CauseProtocol_decode_xer;
+xer_type_encoder_f M2AP_CauseProtocol_encode_xer;
+per_type_decoder_f M2AP_CauseProtocol_decode_uper;
+per_type_encoder_f M2AP_CauseProtocol_encode_uper;
+per_type_decoder_f M2AP_CauseProtocol_decode_aper;
+per_type_encoder_f M2AP_CauseProtocol_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_CauseProtocol_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseRadioNetwork.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_CauseRadioNetwork.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_CauseRadioNetwork_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  5 }	/* (0..5,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_M2AP_CauseRadioNetwork_value2enum_1[] = {
+	{ 0,	45,	"unknown-or-already-allocated-MCE-MBMS-M2AP-ID" },
+	{ 1,	45,	"unknown-or-already-allocated-eNB-MBMS-M2AP-ID" },
+	{ 2,	45,	"unknown-or-inconsistent-pair-of-MBMS-M2AP-IDs" },
+	{ 3,	29,	"radio-resources-not-available" },
+	{ 4,	32,	"interaction-with-other-procedure" },
+	{ 5,	11,	"unspecified" },
+	{ 6,	23,	"invalid-QoS-combination" },
+	{ 7,	23,	"not-supported-QCI-value" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_M2AP_CauseRadioNetwork_enum2value_1[] = {
+	4,	/* interaction-with-other-procedure(4) */
+	6,	/* invalid-QoS-combination(6) */
+	7,	/* not-supported-QCI-value(7) */
+	3,	/* radio-resources-not-available(3) */
+	0,	/* unknown-or-already-allocated-MCE-MBMS-M2AP-ID(0) */
+	1,	/* unknown-or-already-allocated-eNB-MBMS-M2AP-ID(1) */
+	2,	/* unknown-or-inconsistent-pair-of-MBMS-M2AP-IDs(2) */
+	5	/* unspecified(5) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseRadioNetwork_specs_1 = {
+	asn_MAP_M2AP_CauseRadioNetwork_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_M2AP_CauseRadioNetwork_enum2value_1,	/* N => "tag"; sorted by N */
+	8,	/* Number of elements in the maps */
+	7,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_CauseRadioNetwork_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_CauseRadioNetwork = {
+	"CauseRadioNetwork",
+	"CauseRadioNetwork",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_M2AP_CauseRadioNetwork_tags_1,
+	sizeof(asn_DEF_M2AP_CauseRadioNetwork_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseRadioNetwork_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_CauseRadioNetwork_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_CauseRadioNetwork_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseRadioNetwork_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_CauseRadioNetwork_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_M2AP_CauseRadioNetwork_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseRadioNetwork.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_CauseRadioNetwork_H_
+#define	_M2AP_CauseRadioNetwork_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_CauseRadioNetwork {
+	M2AP_CauseRadioNetwork_unknown_or_already_allocated_MCE_MBMS_M2AP_ID	= 0,
+	M2AP_CauseRadioNetwork_unknown_or_already_allocated_eNB_MBMS_M2AP_ID	= 1,
+	M2AP_CauseRadioNetwork_unknown_or_inconsistent_pair_of_MBMS_M2AP_IDs	= 2,
+	M2AP_CauseRadioNetwork_radio_resources_not_available	= 3,
+	M2AP_CauseRadioNetwork_interaction_with_other_procedure	= 4,
+	M2AP_CauseRadioNetwork_unspecified	= 5,
+	/*
+	 * Enumeration is extensible
+	 */
+	M2AP_CauseRadioNetwork_invalid_QoS_combination	= 6,
+	M2AP_CauseRadioNetwork_not_supported_QCI_value	= 7
+} e_M2AP_CauseRadioNetwork;
+
+/* M2AP_CauseRadioNetwork */
+typedef long	 M2AP_CauseRadioNetwork_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_CauseRadioNetwork_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_CauseRadioNetwork;
+extern const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseRadioNetwork_specs_1;
+asn_struct_free_f M2AP_CauseRadioNetwork_free;
+asn_struct_print_f M2AP_CauseRadioNetwork_print;
+asn_constr_check_f M2AP_CauseRadioNetwork_constraint;
+ber_type_decoder_f M2AP_CauseRadioNetwork_decode_ber;
+der_type_encoder_f M2AP_CauseRadioNetwork_encode_der;
+xer_type_decoder_f M2AP_CauseRadioNetwork_decode_xer;
+xer_type_encoder_f M2AP_CauseRadioNetwork_encode_xer;
+per_type_decoder_f M2AP_CauseRadioNetwork_decode_uper;
+per_type_encoder_f M2AP_CauseRadioNetwork_encode_uper;
+per_type_decoder_f M2AP_CauseRadioNetwork_decode_aper;
+per_type_encoder_f M2AP_CauseRadioNetwork_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_CauseRadioNetwork_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseTransport.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_CauseTransport.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_CauseTransport_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0,  1 }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_M2AP_CauseTransport_value2enum_1[] = {
+	{ 0,	30,	"transport-resource-unavailable" },
+	{ 1,	11,	"unspecified" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_M2AP_CauseTransport_enum2value_1[] = {
+	0,	/* transport-resource-unavailable(0) */
+	1	/* unspecified(1) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseTransport_specs_1 = {
+	asn_MAP_M2AP_CauseTransport_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_M2AP_CauseTransport_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_CauseTransport_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_CauseTransport = {
+	"CauseTransport",
+	"CauseTransport",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_M2AP_CauseTransport_tags_1,
+	sizeof(asn_DEF_M2AP_CauseTransport_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseTransport_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_CauseTransport_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_CauseTransport_tags_1)
+		/sizeof(asn_DEF_M2AP_CauseTransport_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_CauseTransport_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_M2AP_CauseTransport_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CauseTransport.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_CauseTransport_H_
+#define	_M2AP_CauseTransport_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_CauseTransport {
+	M2AP_CauseTransport_transport_resource_unavailable	= 0,
+	M2AP_CauseTransport_unspecified	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_M2AP_CauseTransport;
+
+/* M2AP_CauseTransport */
+typedef long	 M2AP_CauseTransport_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_CauseTransport_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_CauseTransport;
+extern const asn_INTEGER_specifics_t asn_SPC_M2AP_CauseTransport_specs_1;
+asn_struct_free_f M2AP_CauseTransport_free;
+asn_struct_print_f M2AP_CauseTransport_print;
+asn_constr_check_f M2AP_CauseTransport_constraint;
+ber_type_decoder_f M2AP_CauseTransport_decode_ber;
+der_type_encoder_f M2AP_CauseTransport_encode_der;
+xer_type_decoder_f M2AP_CauseTransport_decode_xer;
+xer_type_encoder_f M2AP_CauseTransport_encode_xer;
+per_type_decoder_f M2AP_CauseTransport_decode_uper;
+per_type_encoder_f M2AP_CauseTransport_encode_uper;
+per_type_decoder_f M2AP_CauseTransport_decode_aper;
+per_type_encoder_f M2AP_CauseTransport_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_CauseTransport_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Cell-Information-List.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_Cell-Information-List.h"
+
+#include "M2AP_Cell-Information.h"
+asn_per_constraints_t asn_PER_type_M2AP_Cell_Information_List_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1,  256 }	/* (SIZE(1..256)) */,
+	0, 0	/* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_M2AP_Cell_Information_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_M2AP_Cell_Information,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_Cell_Information_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+asn_SET_OF_specifics_t asn_SPC_M2AP_Cell_Information_List_specs_1 = {
+	sizeof(struct M2AP_Cell_Information_List),
+	offsetof(struct M2AP_Cell_Information_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_Cell_Information_List = {
+	"Cell-Information-List",
+	"Cell-Information-List",
+	&asn_OP_SEQUENCE_OF,
+	asn_DEF_M2AP_Cell_Information_List_tags_1,
+	sizeof(asn_DEF_M2AP_Cell_Information_List_tags_1)
+		/sizeof(asn_DEF_M2AP_Cell_Information_List_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_Cell_Information_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_Cell_Information_List_tags_1)
+		/sizeof(asn_DEF_M2AP_Cell_Information_List_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_Cell_Information_List_constr_1, SEQUENCE_OF_constraint },
+	asn_MBR_M2AP_Cell_Information_List_1,
+	1,	/* Single element */
+	&asn_SPC_M2AP_Cell_Information_List_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Cell-Information-List.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_Cell_Information_List_H_
+#define	_M2AP_Cell_Information_List_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct M2AP_Cell_Information;
+
+/* M2AP_Cell-Information-List */
+typedef struct M2AP_Cell_Information_List {
+	A_SEQUENCE_OF(struct M2AP_Cell_Information) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} M2AP_Cell_Information_List_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_Cell_Information_List;
+extern asn_SET_OF_specifics_t asn_SPC_M2AP_Cell_Information_List_specs_1;
+extern asn_TYPE_member_t asn_MBR_M2AP_Cell_Information_List_1[1];
+extern asn_per_constraints_t asn_PER_type_M2AP_Cell_Information_List_constr_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_Cell_Information_List_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Cell-Information.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_Cell-Information.h"
+
+#include "M2AP_ProtocolExtensionContainer.h"
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static asn_per_constraints_t asn_PER_type_M2AP_cellReservationInfo_constr_3 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0,  1 }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_M2AP_cellReservationInfo_value2enum_3[] = {
+	{ 0,	12,	"reservedCell" },
+	{ 1,	15,	"nonReservedCell" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_M2AP_cellReservationInfo_enum2value_3[] = {
+	1,	/* nonReservedCell(1) */
+	0	/* reservedCell(0) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_M2AP_cellReservationInfo_specs_3 = {
+	asn_MAP_M2AP_cellReservationInfo_value2enum_3,	/* "tag" => N; sorted by tag */
+	asn_MAP_M2AP_cellReservationInfo_enum2value_3,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_cellReservationInfo_tags_3[] = {
+	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_M2AP_cellReservationInfo_3 = {
+	"cellReservationInfo",
+	"cellReservationInfo",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_M2AP_cellReservationInfo_tags_3,
+	sizeof(asn_DEF_M2AP_cellReservationInfo_tags_3)
+		/sizeof(asn_DEF_M2AP_cellReservationInfo_tags_3[0]) - 1, /* 1 */
+	asn_DEF_M2AP_cellReservationInfo_tags_3,	/* Same as above */
+	sizeof(asn_DEF_M2AP_cellReservationInfo_tags_3)
+		/sizeof(asn_DEF_M2AP_cellReservationInfo_tags_3[0]), /* 2 */
+	{ 0, &asn_PER_type_M2AP_cellReservationInfo_constr_3, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_M2AP_cellReservationInfo_specs_3	/* Additional specs */
+};
+
+asn_TYPE_member_t asn_MBR_M2AP_Cell_Information_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_Cell_Information, eCGI),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_ECGI,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"eCGI"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct M2AP_Cell_Information, cellReservationInfo),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_cellReservationInfo_3,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"cellReservationInfo"
+		},
+	{ ATF_POINTER, 1, offsetof(struct M2AP_Cell_Information, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_M2AP_ProtocolExtensionContainer_1871P5,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_M2AP_Cell_Information_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_M2AP_Cell_Information_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_M2AP_Cell_Information_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* eCGI */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* cellReservationInfo */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+asn_SEQUENCE_specifics_t asn_SPC_M2AP_Cell_Information_specs_1 = {
+	sizeof(struct M2AP_Cell_Information),
+	offsetof(struct M2AP_Cell_Information, _asn_ctx),
+	asn_MAP_M2AP_Cell_Information_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_M2AP_Cell_Information_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	3,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_Cell_Information = {
+	"Cell-Information",
+	"Cell-Information",
+	&asn_OP_SEQUENCE,
+	asn_DEF_M2AP_Cell_Information_tags_1,
+	sizeof(asn_DEF_M2AP_Cell_Information_tags_1)
+		/sizeof(asn_DEF_M2AP_Cell_Information_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_Cell_Information_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_Cell_Information_tags_1)
+		/sizeof(asn_DEF_M2AP_Cell_Information_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_M2AP_Cell_Information_1,
+	3,	/* Elements count */
+	&asn_SPC_M2AP_Cell_Information_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Cell-Information.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_Cell_Information_H_
+#define	_M2AP_Cell_Information_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "M2AP_ECGI.h"
+#include <NativeEnumerated.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_Cell_Information__cellReservationInfo {
+	M2AP_Cell_Information__cellReservationInfo_reservedCell	= 0,
+	M2AP_Cell_Information__cellReservationInfo_nonReservedCell	= 1
+	/*
+	 * Enumeration is extensible
+	 */
+} e_M2AP_Cell_Information__cellReservationInfo;
+
+/* Forward declarations */
+struct M2AP_ProtocolExtensionContainer;
+
+/* M2AP_Cell-Information */
+typedef struct M2AP_Cell_Information {
+	M2AP_ECGI_t	 eCGI;
+	long	 cellReservationInfo;
+	struct M2AP_ProtocolExtensionContainer	*iE_Extensions;	/* OPTIONAL */
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} M2AP_Cell_Information_t;
+
+/* Implementation */
+/* extern asn_TYPE_descriptor_t asn_DEF_M2AP_cellReservationInfo_3;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_Cell_Information;
+extern asn_SEQUENCE_specifics_t asn_SPC_M2AP_Cell_Information_specs_1;
+extern asn_TYPE_member_t asn_MBR_M2AP_Cell_Information_1[3];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_Cell_Information_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Common-Subframe-Allocation-Period.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_Common-Subframe-Allocation-Period.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_Common_Subframe_Allocation_Period_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  6 }	/* (0..6) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_M2AP_Common_Subframe_Allocation_Period_value2enum_1[] = {
+	{ 0,	3,	"rf4" },
+	{ 1,	3,	"rf8" },
+	{ 2,	4,	"rf16" },
+	{ 3,	4,	"rf32" },
+	{ 4,	4,	"rf64" },
+	{ 5,	5,	"rf128" },
+	{ 6,	5,	"rf256" }
+};
+static const unsigned int asn_MAP_M2AP_Common_Subframe_Allocation_Period_enum2value_1[] = {
+	5,	/* rf128(5) */
+	2,	/* rf16(2) */
+	6,	/* rf256(6) */
+	3,	/* rf32(3) */
+	0,	/* rf4(0) */
+	4,	/* rf64(4) */
+	1	/* rf8(1) */
+};
+const asn_INTEGER_specifics_t asn_SPC_M2AP_Common_Subframe_Allocation_Period_specs_1 = {
+	asn_MAP_M2AP_Common_Subframe_Allocation_Period_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_M2AP_Common_Subframe_Allocation_Period_enum2value_1,	/* N => "tag"; sorted by N */
+	7,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_Common_Subframe_Allocation_Period_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_Common_Subframe_Allocation_Period = {
+	"Common-Subframe-Allocation-Period",
+	"Common-Subframe-Allocation-Period",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_M2AP_Common_Subframe_Allocation_Period_tags_1,
+	sizeof(asn_DEF_M2AP_Common_Subframe_Allocation_Period_tags_1)
+		/sizeof(asn_DEF_M2AP_Common_Subframe_Allocation_Period_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_Common_Subframe_Allocation_Period_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_Common_Subframe_Allocation_Period_tags_1)
+		/sizeof(asn_DEF_M2AP_Common_Subframe_Allocation_Period_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_Common_Subframe_Allocation_Period_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_M2AP_Common_Subframe_Allocation_Period_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Common-Subframe-Allocation-Period.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_Common_Subframe_Allocation_Period_H_
+#define	_M2AP_Common_Subframe_Allocation_Period_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_Common_Subframe_Allocation_Period {
+	M2AP_Common_Subframe_Allocation_Period_rf4	= 0,
+	M2AP_Common_Subframe_Allocation_Period_rf8	= 1,
+	M2AP_Common_Subframe_Allocation_Period_rf16	= 2,
+	M2AP_Common_Subframe_Allocation_Period_rf32	= 3,
+	M2AP_Common_Subframe_Allocation_Period_rf64	= 4,
+	M2AP_Common_Subframe_Allocation_Period_rf128	= 5,
+	M2AP_Common_Subframe_Allocation_Period_rf256	= 6
+} e_M2AP_Common_Subframe_Allocation_Period;
+
+/* M2AP_Common-Subframe-Allocation-Period */
+typedef long	 M2AP_Common_Subframe_Allocation_Period_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_Common_Subframe_Allocation_Period_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_Common_Subframe_Allocation_Period;
+extern const asn_INTEGER_specifics_t asn_SPC_M2AP_Common_Subframe_Allocation_Period_specs_1;
+asn_struct_free_f M2AP_Common_Subframe_Allocation_Period_free;
+asn_struct_print_f M2AP_Common_Subframe_Allocation_Period_print;
+asn_constr_check_f M2AP_Common_Subframe_Allocation_Period_constraint;
+ber_type_decoder_f M2AP_Common_Subframe_Allocation_Period_decode_ber;
+der_type_encoder_f M2AP_Common_Subframe_Allocation_Period_encode_der;
+xer_type_decoder_f M2AP_Common_Subframe_Allocation_Period_decode_xer;
+xer_type_encoder_f M2AP_Common_Subframe_Allocation_Period_encode_xer;
+per_type_decoder_f M2AP_Common_Subframe_Allocation_Period_decode_uper;
+per_type_encoder_f M2AP_Common_Subframe_Allocation_Period_encode_uper;
+per_type_decoder_f M2AP_Common_Subframe_Allocation_Period_decode_aper;
+per_type_encoder_f M2AP_Common_Subframe_Allocation_Period_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_Common_Subframe_Allocation_Period_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CountingResult.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-PDU-Contents"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_CountingResult.h"
+
+int
+M2AP_CountingResult_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 1023)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_CountingResult_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 10,  10,  0,  1023 }	/* (0..1023) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_CountingResult_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_CountingResult = {
+	"CountingResult",
+	"CountingResult",
+	&asn_OP_NativeInteger,
+	asn_DEF_M2AP_CountingResult_tags_1,
+	sizeof(asn_DEF_M2AP_CountingResult_tags_1)
+		/sizeof(asn_DEF_M2AP_CountingResult_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_CountingResult_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_CountingResult_tags_1)
+		/sizeof(asn_DEF_M2AP_CountingResult_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_CountingResult_constr_1, M2AP_CountingResult_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CountingResult.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-PDU-Contents"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_CountingResult_H_
+#define	_M2AP_CountingResult_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* M2AP_CountingResult */
+typedef long	 M2AP_CountingResult_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_CountingResult_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_CountingResult;
+asn_struct_free_f M2AP_CountingResult_free;
+asn_struct_print_f M2AP_CountingResult_print;
+asn_constr_check_f M2AP_CountingResult_constraint;
+ber_type_decoder_f M2AP_CountingResult_decode_ber;
+der_type_encoder_f M2AP_CountingResult_encode_der;
+xer_type_decoder_f M2AP_CountingResult_decode_xer;
+xer_type_encoder_f M2AP_CountingResult_encode_xer;
+per_type_decoder_f M2AP_CountingResult_decode_uper;
+per_type_encoder_f M2AP_CountingResult_encode_uper;
+per_type_decoder_f M2AP_CountingResult_decode_aper;
+per_type_encoder_f M2AP_CountingResult_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_CountingResult_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Criticality.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-CommonDataTypes"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#include "M2AP_Criticality.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_M2AP_Criticality_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0,  2 }	/* (0..2) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_M2AP_Criticality_value2enum_1[] = {
+	{ 0,	6,	"reject" },
+	{ 1,	6,	"ignore" },
+	{ 2,	6,	"notify" }
+};
+static const unsigned int asn_MAP_M2AP_Criticality_enum2value_1[] = {
+	1,	/* ignore(1) */
+	2,	/* notify(2) */
+	0	/* reject(0) */
+};
+const asn_INTEGER_specifics_t asn_SPC_M2AP_Criticality_specs_1 = {
+	asn_MAP_M2AP_Criticality_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_M2AP_Criticality_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_M2AP_Criticality_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_M2AP_Criticality = {
+	"Criticality",
+	"Criticality",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_M2AP_Criticality_tags_1,
+	sizeof(asn_DEF_M2AP_Criticality_tags_1)
+		/sizeof(asn_DEF_M2AP_Criticality_tags_1[0]), /* 1 */
+	asn_DEF_M2AP_Criticality_tags_1,	/* Same as above */
+	sizeof(asn_DEF_M2AP_Criticality_tags_1)
+		/sizeof(asn_DEF_M2AP_Criticality_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_M2AP_Criticality_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_M2AP_Criticality_specs_1	/* Additional specs */
+};
+

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_Criticality.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-CommonDataTypes"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_Criticality_H_
+#define	_M2AP_Criticality_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum M2AP_Criticality {
+	M2AP_Criticality_reject	= 0,
+	M2AP_Criticality_ignore	= 1,
+	M2AP_Criticality_notify	= 2
+} e_M2AP_Criticality;
+
+/* M2AP_Criticality */
+typedef long	 M2AP_Criticality_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_M2AP_Criticality_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_Criticality;
+extern const asn_INTEGER_specifics_t asn_SPC_M2AP_Criticality_specs_1;
+asn_struct_free_f M2AP_Criticality_free;
+asn_struct_print_f M2AP_Criticality_print;
+asn_constr_check_f M2AP_Criticality_constraint;
+ber_type_decoder_f M2AP_Criticality_decode_ber;
+der_type_encoder_f M2AP_Criticality_encode_der;
+xer_type_decoder_f M2AP_Criticality_decode_xer;
+xer_type_encoder_f M2AP_Criticality_encode_xer;
+per_type_decoder_f M2AP_Criticality_decode_uper;
+per_type_encoder_f M2AP_Criticality_encode_uper;
+per_type_decoder_f M2AP_Criticality_decode_aper;
+per_type_encoder_f M2AP_Criticality_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_Criticality_H_ */
+#include <asn_internal.h>

openair2/M2AP/MESSAGES/ASN1/R14/m2ap-14.0.0.gen/M2AP_CriticalityDiagnostics.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "M2AP-Ies"
+ * 	found in "R14/m2ap-14.0.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -fno-include-deps -D R14/m2ap-14.0.0.gen/`
+ */
+
+#ifndef	_M2AP_CriticalityDiagnostics_H_
+#define	_M2AP_CriticalityDiagnostics_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "M2AP_ProcedureCode.h"
+#include "M2AP_TriggeringMessage.h"
+#include "M2AP_Criticality.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct M2AP_CriticalityDiagnostics_IE_List;
+struct M2AP_ProtocolExtensionContainer;
+
+/* M2AP_CriticalityDiagnostics */
+typedef struct M2AP_CriticalityDiagnostics {
+	M2AP_ProcedureCode_t	*procedureCode;	/* OPTIONAL */
+	M2AP_TriggeringMessage_t	*triggeringMessage;	/* OPTIONAL */
+	M2AP_Criticality_t	*procedureCriticality;	/* OPTIONAL */
+	struct M2AP_CriticalityDiagnostics_IE_List	*iEsCriticalityDiagnostics;	/* OPTIONAL */
+	struct M2AP_ProtocolExtensionContainer	*iE_Extensions;	/* OPTIONAL */
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} M2AP_CriticalityDiagnostics_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_M2AP_CriticalityDiagnostics;
+extern asn_SEQUENCE_specifics_t asn_SPC_M2AP_CriticalityDiagnostics_specs_1;
+extern asn_TYPE_member_t asn_MBR_M2AP_CriticalityDiagnostics_1[5];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _M2AP_CriticalityDiagnostics_H_ */
+#include <asn_internal.h>